diff --git a/plugins/awesome-claude-skills/-21risk-automation/SKILL.md b/plugins/awesome-claude-skills/-21risk-automation/SKILL.md new file mode 100644 index 0000000..7a7a784 --- /dev/null +++ b/plugins/awesome-claude-skills/-21risk-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: -21risk-automation +description: "Automate 21risk tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# 21risk Automation via Rube MCP + +Automate 21risk operations through Composio's 21risk toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/_21risk](https://composio.dev/toolkits/_21risk) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active 21risk connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `_21risk` +- 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 `_21risk` +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: "21risk 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 21risk task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["_21risk"] +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 21risk-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `_21risk` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/-2chat-automation/SKILL.md b/plugins/awesome-claude-skills/-2chat-automation/SKILL.md new file mode 100644 index 0000000..a390d0a --- /dev/null +++ b/plugins/awesome-claude-skills/-2chat-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: -2chat-automation +description: "Automate 2chat tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# 2chat Automation via Rube MCP + +Automate 2chat operations through Composio's 2chat toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/_2chat](https://composio.dev/toolkits/_2chat) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active 2chat connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `_2chat` +- 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 `_2chat` +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: "2chat 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 2chat task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["_2chat"] +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 2chat-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `_2chat` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/README.md b/plugins/awesome-claude-skills/README.md index fe936aa..25a7af1 100644 --- a/plugins/awesome-claude-skills/README.md +++ b/plugins/awesome-claude-skills/README.md @@ -2,7 +2,7 @@

- Composio banner + Composio banner @@ -36,8 +36,42 @@ A curated list of practical Claude Skills for enhancing productivity across Claude.ai, Claude Code, and the Claude API. -> If you want your skills to take actions across 500+ apps, wire them up with [Composio](https://platform.composio.dev/?utm_source=Github&utm_medium=Youtube&utm_campaign=2025-11&utm_content=AwesomeSkills) +> **Want skills that do more than generate text?** Claude can send emails, create issues, post to Slack, and take actions across 1000+ apps. [See how →](./connect/) +--- + +## Quickstart: Connect Claude to 500+ Apps + +The **connect-apps** plugin lets Claude perform real actions - send emails, create issues, post to Slack. It handles auth and connects to 500+ apps using Composio under the hood. + +### 1. Install the Plugin + +```bash +claude --plugin-dir ./connect-apps-plugin +``` + +### 2. Run Setup + +``` +/connect-apps:setup +``` + +Paste your API key when asked. (Get a free key at [platform.composio.dev](https://platform.composio.dev/?utm_source=Github&utm_content=AwesomeSkills)) + +### 3. Restart & Try It + +```bash +exit +claude +``` + +> **Want skills that do more than generate text?** Claude can send emails, create issues, post to Slack, and take actions across 1000+ apps. [See how →](./connect/) + +If you receive the email, Claude is now connected to 500+ apps. + +**[See all supported apps →](https://composio.dev/toolkits)** + +--- ## Contents @@ -52,6 +86,7 @@ A curated list of practical Claude Skills for enhancing productivity across Clau - [Productivity & Organization](#productivity--organization) - [Collaboration & Project Management](#collaboration--project-management) - [Security & Systems](#security--systems) + - [App Automation via Composio](#app-automation-via-composio) - [Getting Started](#getting-started) - [Creating Skills](#creating-skills) - [Contributing](#contributing) @@ -74,7 +109,7 @@ Claude Skills are customizable workflows that teach Claude how to perform specif ### Development & Code Tools -- [artifacts-builder](https://github.com/anthropics/skills/tree/main/web-artifacts-builder) - Suite of tools for creating elaborate, multi-component claude.ai HTML artifacts using modern frontend web technologies (React, Tailwind CSS, shadcn/ui). +- [artifacts-builder](https://github.com/anthropics/skills/tree/main/skills/web-artifacts-builder) - Suite of tools for creating elaborate, multi-component claude.ai HTML artifacts using modern frontend web technologies (React, Tailwind CSS, shadcn/ui). - [aws-skills](https://github.com/zxkane/aws-skills) - AWS development with CDK best practices, cost optimization MCP servers, and serverless/event-driven architecture patterns. - [Changelog Generator](./changelog-generator/) - Automatically creates user-facing changelogs from git commits by analyzing history and transforming technical commits into customer-friendly release notes. - [Claude Code Terminal Title](https://github.com/bluzername/claude-code-terminal-title) - Gives each Claud-Code terminal window a dynamic title that describes the work being done so you don't lose track of what window is doing what. @@ -82,22 +117,27 @@ Claude Skills are customizable workflows that teach Claude how to perform specif - [FFUF Web Fuzzing](https://github.com/jthack/ffuf_claude_skill) - Integrates the ffuf web fuzzer so Claude can run fuzzing tasks and analyze results for vulnerabilities. *By [@jthack](https://github.com/jthack)* - [finishing-a-development-branch](https://github.com/obra/superpowers/tree/main/skills/finishing-a-development-branch) - Guides completion of development work by presenting clear options and handling chosen workflow. - [iOS Simulator](https://github.com/conorluddy/ios-simulator-skill) - Enables Claude to interact with iOS Simulator for testing and debugging iOS applications. *By [@conorluddy](https://github.com/conorluddy)* +- [jules](https://github.com/sanjay3290/ai-skills/tree/main/skills/jules) - Delegate coding tasks to Google Jules AI agent for async bug fixes, documentation, tests, and feature implementation on GitHub repos. *By [@sanjay3290](https://github.com/sanjay3290)* +- [LangSmith Fetch](./langsmith-fetch/) - Debug LangChain and LangGraph agents by automatically fetching and analyzing execution traces from LangSmith Studio. First AI observability skill for Claude Code. *By [@OthmanAdi](https://github.com/OthmanAdi)* - [MCP Builder](./mcp-builder/) - Guides creation of high-quality MCP (Model Context Protocol) servers for integrating external APIs and services with LLMs using Python or TypeScript. - [move-code-quality-skill](https://github.com/1NickPappas/move-code-quality-skill) - Analyzes Move language packages against the official Move Book Code Quality Checklist for Move 2024 Edition compliance and best practices. - [Playwright Browser Automation](https://github.com/lackeyjb/playwright-skill) - Model-invoked Playwright automation for testing and validating web applications. *By [@lackeyjb](https://github.com/lackeyjb)* - [prompt-engineering](https://github.com/NeoLabHQ/context-engineering-kit/tree/master/plugins/customaize-agent/skills/prompt-engineering) - Teaches well-known prompt engineering techniques and patterns, including Anthropic best practices and agent persuasion principles. - [pypict-claude-skill](https://github.com/omkamal/pypict-claude-skill) - Design comprehensive test cases using PICT (Pairwise Independent Combinatorial Testing) for requirements or code, generating optimized test suites with pairwise coverage. +- [reddit-fetch](https://github.com/ykdojo/claude-code-tips/tree/main/skills/reddit-fetch) - Fetches Reddit content via Gemini CLI when WebFetch is blocked or returns 403 errors. - [Skill Creator](./skill-creator/) - Provides guidance for creating effective Claude Skills that extend capabilities with specialized knowledge, workflows, and tool integrations. - [Skill Seekers](https://github.com/yusufkaraaslan/Skill_Seekers) - Automatically converts any documentation website into a Claude AI skill in minutes. *By [@yusufkaraaslan](https://github.com/yusufkaraaslan)* - [software-architecture](https://github.com/NeoLabHQ/context-engineering-kit/tree/master/plugins/ddd/skills/software-architecture) - Implements design patterns including Clean Architecture, SOLID principles, and comprehensive software design best practices. - [subagent-driven-development](https://github.com/NeoLabHQ/context-engineering-kit/tree/master/plugins/sadd/skills/subagent-driven-development) - Dispatches independent subagents for individual tasks with code review checkpoints between iterations for rapid, controlled development. - [test-driven-development](https://github.com/obra/superpowers/tree/main/skills/test-driven-development) - Use when implementing any feature or bugfix, before writing implementation code. - [using-git-worktrees](https://github.com/obra/superpowers/blob/main/skills/using-git-worktrees/) - Creates isolated git worktrees with smart directory selection and safety verification. +- [Connect](./connect/) - Connect Claude to any app. Send emails, create issues, post messages, update databases - take real actions across Gmail, Slack, GitHub, Notion, and 1000+ services. - [Webapp Testing](./webapp-testing/) - Tests local web applications using Playwright for verifying frontend functionality, debugging UI behavior, and capturing screenshots. ### Data & Analysis - [CSV Data Summarizer](https://github.com/coffeefuelbump/csv-data-summarizer-claude-skill) - Automatically analyzes CSV files and generates comprehensive insights with visualizations without requiring user prompts. *By [@coffeefuelbump](https://github.com/coffeefuelbump)* +- [deep-research](https://github.com/sanjay3290/ai-skills/tree/main/skills/deep-research) - Execute autonomous multi-step research using Gemini Deep Research Agent for market analysis, competitive landscaping, and literature reviews. *By [@sanjay3290](https://github.com/sanjay3290)* - [postgres](https://github.com/sanjay3290/ai-skills/tree/main/skills/postgres) - Execute safe read-only SQL queries against PostgreSQL databases with multi-connection support and defense-in-depth security. *By [@sanjay3290](https://github.com/sanjay3290)* - [root-cause-tracing](https://github.com/obra/superpowers/tree/main/skills/root-cause-tracing) - Use when errors occur deep in execution and you need to trace back to find the original trigger. @@ -117,6 +157,7 @@ Claude Skills are customizable workflows that teach Claude how to perform specif - [family-history-research](https://github.com/emaynard/claude-family-history-research-skill) - Provides assistance with planning family history and genealogy research projects. - [Meeting Insights Analyzer](./meeting-insights-analyzer/) - Analyzes meeting transcripts to uncover behavioral patterns including conflict avoidance, speaking ratios, filler words, and leadership style. - [NotebookLM Integration](https://github.com/PleasePrompto/notebooklm-skill) - Lets Claude Code chat directly with NotebookLM for source-grounded answers based exclusively on uploaded documents. *By [@PleasePrompto](https://github.com/PleasePrompto)* +- [Twitter Algorithm Optimizer](./twitter-algorithm-optimizer/) - Analyze and optimize tweets for maximum reach using Twitter's open-source algorithm insights. Rewrite and edit tweets to improve engagement and visibility. ### Creative & Media @@ -135,12 +176,15 @@ Claude Skills are customizable workflows that teach Claude how to perform specif - [kaizen](https://github.com/NeoLabHQ/context-engineering-kit/tree/master/plugins/kaizen/skills/kaizen) - Applies continuous improvement methodology with multiple analytical approaches, based on Japanese Kaizen philosophy and Lean methodology. - [n8n-skills](https://github.com/haunchen/n8n-skills) - Enables AI assistants to directly understand and operate n8n workflows. - [Raffle Winner Picker](./raffle-winner-picker/) - Randomly selects winners from lists, spreadsheets, or Google Sheets for giveaways and contests with cryptographically secure randomness. +- [Tailored Resume Generator](./tailored-resume-generator/) - Analyzes job descriptions and generates tailored resumes that highlight relevant experience, skills, and achievements to maximize interview chances. - [ship-learn-next](https://github.com/michalparkola/tapestry-skills-for-claude-code/tree/main/ship-learn-next) - Skill to help iterate on what to build or learn next, based on feedback loops. - [tapestry](https://github.com/michalparkola/tapestry-skills-for-claude-code/tree/main/tapestry) - Interlink and summarize related documents into knowledge networks. ### Collaboration & Project Management - [git-pushing](https://github.com/mhattingpete/claude-skills-marketplace/tree/main/engineering-workflow-plugin/skills/git-pushing) - Automate git operations and repository interactions. +- [google-workspace-skills](https://github.com/sanjay3290/ai-skills/tree/main/skills) - Suite of Google Workspace integrations: Gmail, Calendar, Chat, Docs, Sheets, Slides, and Drive with cross-platform OAuth. *By [@sanjay3290](https://github.com/sanjay3290)* +- [outline](https://github.com/sanjay3290/ai-skills/tree/main/skills/outline) - Search, read, create, and manage documents in Outline wiki instances (cloud or self-hosted). *By [@sanjay3290](https://github.com/sanjay3290)* - [review-implementing](https://github.com/mhattingpete/claude-skills-marketplace/tree/main/engineering-workflow-plugin/skills/review-implementing) - Evaluate code implementation plans and align with specs. - [test-fixing](https://github.com/mhattingpete/claude-skills-marketplace/tree/main/engineering-workflow-plugin/skills/test-fixing) - Detect failing tests and propose patches or fixes. @@ -151,6 +195,122 @@ Claude Skills are customizable workflows that teach Claude how to perform specif - [metadata-extraction](https://github.com/mhattingpete/claude-skills-marketplace/tree/main/computer-forensics-skills/skills/metadata-extraction) - Extract and analyze file metadata for forensic purposes. - [threat-hunting-with-sigma-rules](https://github.com/jthack/threat-hunting-with-sigma-rules-skill) - Use Sigma detection rules to hunt for threats and analyze security events. +### App Automation via Composio + +Pre-built workflow skills for 78 SaaS apps via [Rube MCP (Composio)](https://composio.dev). Each skill includes tool sequences, parameter guidance, known pitfalls, and quick reference tables — all using real tool slugs discovered from Composio's API. + +**CRM & Sales** +- [Close Automation](./close-automation/) - Automate Close CRM: leads, contacts, opportunities, activities, and pipelines. +- [HubSpot Automation](./hubspot-automation/) - Automate HubSpot CRM: contacts, deals, companies, tickets, and email engagement. +- [Pipedrive Automation](./pipedrive-automation/) - Automate Pipedrive: deals, contacts, organizations, activities, and pipelines. +- [Salesforce Automation](./salesforce-automation/) - Automate Salesforce: objects, records, SOQL queries, and bulk operations. +- [Zoho CRM Automation](./zoho-crm-automation/) - Automate Zoho CRM: leads, contacts, deals, accounts, and modules. + +**Project Management** +- [Asana Automation](./asana-automation/) - Automate Asana: tasks, projects, sections, assignments, and workspaces. +- [Basecamp Automation](./basecamp-automation/) - Automate Basecamp: to-do lists, messages, people, groups, and projects. +- [ClickUp Automation](./clickup-automation/) - Automate ClickUp: tasks, lists, spaces, goals, and time tracking. +- [Jira Automation](./jira-automation/) - Automate Jira: issues, projects, boards, sprints, and JQL queries. +- [Linear Automation](./linear-automation/) - Automate Linear: issues, projects, cycles, teams, and workflows. +- [Monday Automation](./monday-automation/) - Automate Monday.com: boards, items, columns, groups, and workspaces. +- [Notion Automation](./notion-automation/) - Automate Notion: pages, databases, blocks, comments, and search. +- [Todoist Automation](./todoist-automation/) - Automate Todoist: tasks, projects, sections, labels, and filters. +- [Trello Automation](./trello-automation/) - Automate Trello: boards, cards, lists, members, and checklists. +- [Wrike Automation](./wrike-automation/) - Automate Wrike: tasks, folders, projects, comments, and workflows. + +**Communication** +- [Discord Automation](./discord-automation/) - Automate Discord: messages, channels, servers, roles, and reactions. +- [Intercom Automation](./intercom-automation/) - Automate Intercom: conversations, contacts, companies, tickets, and articles. +- [Microsoft Teams Automation](./microsoft-teams-automation/) - Automate Teams: messages, channels, teams, chats, and meetings. +- [Slack Automation](./slack-automation/) - Automate Slack: messages, channels, search, reactions, threads, and scheduling. +- [Telegram Automation](./telegram-automation/) - Automate Telegram: messages, chats, media, groups, and bots. +- [WhatsApp Automation](./whatsapp-automation/) - Automate WhatsApp: messages, media, templates, groups, and business profiles. + +**Email** +- [Gmail Automation](./gmail-automation/) - Automate Gmail: send/reply, search, labels, drafts, and attachments. +- [Outlook Automation](./outlook-automation/) - Automate Outlook: emails, folders, contacts, and calendar integration. +- [Postmark Automation](./postmark-automation/) - Automate Postmark: transactional emails, templates, servers, and delivery stats. +- [SendGrid Automation](./sendgrid-automation/) - Automate SendGrid: emails, templates, contacts, lists, and campaign stats. + +**Code & DevOps** +- [Bitbucket Automation](./bitbucket-automation/) - Automate Bitbucket: repos, PRs, branches, issues, and workspaces. +- [CircleCI Automation](./circleci-automation/) - Automate CircleCI: pipelines, workflows, jobs, and project configuration. +- [Datadog Automation](./datadog-automation/) - Automate Datadog: monitors, dashboards, metrics, incidents, and alerts. +- [GitHub Automation](./github-automation/) - Automate GitHub: issues, PRs, repos, branches, actions, and code search. +- [GitLab Automation](./gitlab-automation/) - Automate GitLab: issues, MRs, projects, pipelines, and branches. +- [PagerDuty Automation](./pagerduty-automation/) - Automate PagerDuty: incidents, services, schedules, escalation policies, and on-call. +- [Render Automation](./render-automation/) - Automate Render: services, deploys, and project management. +- [Sentry Automation](./sentry-automation/) - Automate Sentry: issues, events, projects, releases, and alerts. +- [Supabase Automation](./supabase-automation/) - Automate Supabase: SQL queries, table schemas, edge functions, and storage. +- [Vercel Automation](./vercel-automation/) - Automate Vercel: deployments, projects, domains, environment variables, and logs. + +**Storage & Files** +- [Box Automation](./box-automation/) - Automate Box: files, folders, search, sharing, collaborations, and sign requests. +- [Dropbox Automation](./dropbox-automation/) - Automate Dropbox: files, folders, search, sharing, and batch operations. +- [Google Drive Automation](./google-drive-automation/) - Automate Google Drive: upload, download, search, share, and organize files. +- [OneDrive Automation](./one-drive-automation/) - Automate OneDrive: files, folders, search, sharing, permissions, and versioning. + +**Spreadsheets & Databases** +- [Airtable Automation](./airtable-automation/) - Automate Airtable: records, tables, bases, views, and field management. +- [Coda Automation](./coda-automation/) - Automate Coda: docs, tables, rows, formulas, and automations. +- [Google Sheets Automation](./googlesheets-automation/) - Automate Google Sheets: read/write cells, formatting, formulas, and batch operations. + +**Calendar & Scheduling** +- [Cal.com Automation](./cal-com-automation/) - Automate Cal.com: event types, bookings, availability, and scheduling. +- [Calendly Automation](./calendly-automation/) - Automate Calendly: events, invitees, event types, scheduling links, and availability. +- [Google Calendar Automation](./google-calendar-automation/) - Automate Google Calendar: events, attendees, free/busy, and recurring schedules. +- [Outlook Calendar Automation](./outlook-calendar-automation/) - Automate Outlook Calendar: events, attendees, reminders, and recurring schedules. + +**Social Media** +- [Instagram Automation](./instagram-automation/) - Automate Instagram: posts, stories, comments, media, and business insights. +- [LinkedIn Automation](./linkedin-automation/) - Automate LinkedIn: posts, profiles, companies, images, and comments. +- [Reddit Automation](./reddit-automation/) - Automate Reddit: posts, comments, subreddits, voting, and moderation. +- [TikTok Automation](./tiktok-automation/) - Automate TikTok: video uploads, queries, and creator management. +- [Twitter Automation](./twitter-automation/) - Automate Twitter/X: tweets, search, users, lists, and engagement. +- [YouTube Automation](./youtube-automation/) - Automate YouTube: videos, channels, playlists, comments, and subscriptions. + +**Marketing & Email Marketing** +- [ActiveCampaign Automation](./activecampaign-automation/) - Automate ActiveCampaign: contacts, deals, campaigns, lists, and automations. +- [Brevo Automation](./brevo-automation/) - Automate Brevo: contacts, email campaigns, transactional emails, and lists. +- [ConvertKit Automation](./convertkit-automation/) - Automate ConvertKit (Kit): subscribers, tags, sequences, broadcasts, and forms. +- [Klaviyo Automation](./klaviyo-automation/) - Automate Klaviyo: profiles, lists, segments, campaigns, and events. +- [Mailchimp Automation](./mailchimp-automation/) - Automate Mailchimp: audiences, campaigns, templates, segments, and reports. + +**Support & Helpdesk** +- [Freshdesk Automation](./freshdesk-automation/) - Automate Freshdesk: tickets, contacts, agents, groups, and canned responses. +- [Freshservice Automation](./freshservice-automation/) - Automate Freshservice: tickets, assets, changes, problems, and service catalog. +- [Help Scout Automation](./helpdesk-automation/) - Automate Help Scout: conversations, customers, mailboxes, and tags. +- [Zendesk Automation](./zendesk-automation/) - Automate Zendesk: tickets, users, organizations, search, and macros. + +**E-commerce & Payments** +- [Shopify Automation](./shopify-automation/) - Automate Shopify: products, orders, customers, inventory, and GraphQL queries. +- [Square Automation](./square-automation/) - Automate Square: payments, customers, catalog, orders, and locations. +- [Stripe Automation](./stripe-automation/) - Automate Stripe: charges, customers, products, subscriptions, and refunds. + +**Design & Collaboration** +- [Canva Automation](./canva-automation/) - Automate Canva: designs, templates, assets, folders, and brand kits. +- [Confluence Automation](./confluence-automation/) - Automate Confluence: pages, spaces, search, CQL, labels, and versions. +- [DocuSign Automation](./docusign-automation/) - Automate DocuSign: envelopes, templates, signing, and document management. +- [Figma Automation](./figma-automation/) - Automate Figma: files, components, comments, projects, and team management. +- [Miro Automation](./miro-automation/) - Automate Miro: boards, sticky notes, shapes, connectors, and items. +- [Webflow Automation](./webflow-automation/) - Automate Webflow: CMS collections, items, sites, publishing, and assets. + +**Analytics & Data** +- [Amplitude Automation](./amplitude-automation/) - Automate Amplitude: events, cohorts, user properties, and analytics queries. +- [Google Analytics Automation](./google-analytics-automation/) - Automate Google Analytics: reports, dimensions, metrics, and property management. +- [Mixpanel Automation](./mixpanel-automation/) - Automate Mixpanel: events, funnels, cohorts, annotations, and JQL queries. +- [PostHog Automation](./posthog-automation/) - Automate PostHog: events, persons, feature flags, insights, and annotations. +- [Segment Automation](./segment-automation/) - Automate Segment: sources, destinations, tracking, and warehouse connections. + +**HR & People** +- [BambooHR Automation](./bamboohr-automation/) - Automate BambooHR: employees, time off, reports, and directory management. + +**Automation Platforms** +- [Make Automation](./make-automation/) - Automate Make (Integromat): scenarios, connections, and execution management. + +**Zoom & Meetings** +- [Zoom Automation](./zoom-automation/) - Automate Zoom: meetings, recordings, participants, webinars, and reports. + ## Getting Started ### Using Skills in Claude.ai @@ -288,9 +448,21 @@ We welcome contributions! Please read our [Contributing Guidelines](CONTRIBUTING ## Join the Community -- Have questions about integrating Composio with your auth setup? [Hop on a quick call with us](https://calendly.com/thomas-composio/composio-enterprise-setup) -- [Follow us on Twitter](https://x.com/composio) -- [Join our Discord](https://discord.com/invite/composio) +- [Join our Discord](https://discord.com/invite/composio) - Chat with other developers building Claude Skills +- [Follow on Twitter/X](https://x.com/composio) - Stay updated on new skills and features +- Questions? [support@composio.dev](mailto:support@composio.dev) + +--- + +

+ Join 20,000+ developers building agents that ship +

+ +

+ + Get Started + +

## License diff --git a/plugins/awesome-claude-skills/ably-automation/SKILL.md b/plugins/awesome-claude-skills/ably-automation/SKILL.md new file mode 100644 index 0000000..4bb303e --- /dev/null +++ b/plugins/awesome-claude-skills/ably-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: ably-automation +description: "Automate Ably tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Ably Automation via Rube MCP + +Automate Ably operations through Composio's Ably toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/ably](https://composio.dev/toolkits/ably) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Ably connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ably` +- 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 `ably` +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: "Ably 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 Ably task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["ably"] +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 Ably-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ably` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/abstract-automation/SKILL.md b/plugins/awesome-claude-skills/abstract-automation/SKILL.md new file mode 100644 index 0000000..a816a76 --- /dev/null +++ b/plugins/awesome-claude-skills/abstract-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: abstract-automation +description: "Automate Abstract tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Abstract Automation via Rube MCP + +Automate Abstract operations through Composio's Abstract toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/abstract](https://composio.dev/toolkits/abstract) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Abstract connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `abstract` +- 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 `abstract` +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: "Abstract 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 Abstract task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["abstract"] +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 Abstract-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `abstract` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/abuselpdb-automation/SKILL.md b/plugins/awesome-claude-skills/abuselpdb-automation/SKILL.md new file mode 100644 index 0000000..00bd03f --- /dev/null +++ b/plugins/awesome-claude-skills/abuselpdb-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: abuselpdb-automation +description: "Automate Abuselpdb tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Abuselpdb Automation via Rube MCP + +Automate Abuselpdb operations through Composio's Abuselpdb toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/abuselpdb](https://composio.dev/toolkits/abuselpdb) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Abuselpdb connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `abuselpdb` +- 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 `abuselpdb` +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: "Abuselpdb 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 Abuselpdb task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["abuselpdb"] +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 Abuselpdb-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `abuselpdb` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/abyssale-automation/SKILL.md b/plugins/awesome-claude-skills/abyssale-automation/SKILL.md new file mode 100644 index 0000000..0f18791 --- /dev/null +++ b/plugins/awesome-claude-skills/abyssale-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: abyssale-automation +description: "Automate Abyssale tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Abyssale Automation via Rube MCP + +Automate Abyssale operations through Composio's Abyssale toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/abyssale](https://composio.dev/toolkits/abyssale) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Abyssale connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `abyssale` +- 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 `abyssale` +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: "Abyssale 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 Abyssale task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["abyssale"] +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 Abyssale-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `abyssale` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/accelo-automation/SKILL.md b/plugins/awesome-claude-skills/accelo-automation/SKILL.md new file mode 100644 index 0000000..5252a20 --- /dev/null +++ b/plugins/awesome-claude-skills/accelo-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: accelo-automation +description: "Automate Accelo tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Accelo Automation via Rube MCP + +Automate Accelo operations through Composio's Accelo toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/accelo](https://composio.dev/toolkits/accelo) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Accelo connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `accelo` +- 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 `accelo` +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: "Accelo 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 Accelo task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["accelo"] +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 Accelo-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `accelo` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/accredible-certificates-automation/SKILL.md b/plugins/awesome-claude-skills/accredible-certificates-automation/SKILL.md new file mode 100644 index 0000000..ff5e3ad --- /dev/null +++ b/plugins/awesome-claude-skills/accredible-certificates-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: accredible-certificates-automation +description: "Automate Accredible Certificates tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Accredible Certificates Automation via Rube MCP + +Automate Accredible Certificates operations through Composio's Accredible Certificates toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/accredible_certificates](https://composio.dev/toolkits/accredible_certificates) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Accredible Certificates connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `accredible_certificates` +- 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 `accredible_certificates` +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: "Accredible Certificates 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 Accredible Certificates task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["accredible_certificates"] +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 Accredible Certificates-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `accredible_certificates` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/acculynx-automation/SKILL.md b/plugins/awesome-claude-skills/acculynx-automation/SKILL.md new file mode 100644 index 0000000..aaf8071 --- /dev/null +++ b/plugins/awesome-claude-skills/acculynx-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: acculynx-automation +description: "Automate Acculynx tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Acculynx Automation via Rube MCP + +Automate Acculynx operations through Composio's Acculynx toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/acculynx](https://composio.dev/toolkits/acculynx) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Acculynx connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `acculynx` +- 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 `acculynx` +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: "Acculynx 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 Acculynx task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["acculynx"] +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 Acculynx-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `acculynx` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/active-campaign-automation/SKILL.md b/plugins/awesome-claude-skills/active-campaign-automation/SKILL.md new file mode 100644 index 0000000..427dece --- /dev/null +++ b/plugins/awesome-claude-skills/active-campaign-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: active-campaign-automation +description: "Automate ActiveCampaign tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# ActiveCampaign Automation via Rube MCP + +Automate ActiveCampaign operations through Composio's ActiveCampaign toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/active_campaign](https://composio.dev/toolkits/active_campaign) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active ActiveCampaign connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `active_campaign` +- 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 `active_campaign` +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: "ActiveCampaign 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 ActiveCampaign task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["active_campaign"] +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 ActiveCampaign-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `active_campaign` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/activecampaign-automation/SKILL.md b/plugins/awesome-claude-skills/activecampaign-automation/SKILL.md new file mode 100644 index 0000000..60d8120 --- /dev/null +++ b/plugins/awesome-claude-skills/activecampaign-automation/SKILL.md @@ -0,0 +1,214 @@ +--- +name: activecampaign-automation +description: "Automate ActiveCampaign tasks via Rube MCP (Composio): manage contacts, tags, list subscriptions, automation enrollment, and tasks. Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# ActiveCampaign Automation via Rube MCP + +Automate ActiveCampaign CRM and marketing automation operations through Composio's ActiveCampaign toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/active_campaign](https://composio.dev/toolkits/active_campaign) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active ActiveCampaign connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `active_campaign` +- 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 `active_campaign` +3. If connection is not ACTIVE, follow the returned auth link to complete ActiveCampaign authentication +4. Confirm connection status shows ACTIVE before running any workflows + +## Core Workflows + +### 1. Create and Find Contacts + +**When to use**: User wants to create new contacts or look up existing ones + +**Tool sequence**: +1. `ACTIVE_CAMPAIGN_FIND_CONTACT` - Search for an existing contact [Optional] +2. `ACTIVE_CAMPAIGN_CREATE_CONTACT` - Create a new contact [Required] + +**Key parameters for find**: +- `email`: Search by email address +- `id`: Search by ActiveCampaign contact ID +- `phone`: Search by phone number + +**Key parameters for create**: +- `email`: Contact email address (required) +- `first_name`: Contact first name +- `last_name`: Contact last name +- `phone`: Contact phone number +- `organization_name`: Contact's organization +- `job_title`: Contact's job title +- `tags`: Comma-separated list of tags to apply + +**Pitfalls**: +- `email` is the only required field for contact creation +- Phone search uses a general search parameter internally; it may return partial matches +- When combining `email` and `phone` in FIND_CONTACT, results are filtered client-side +- Tags provided during creation are applied immediately +- Creating a contact with an existing email may update the existing contact + +### 2. Manage Contact Tags + +**When to use**: User wants to add or remove tags from contacts + +**Tool sequence**: +1. `ACTIVE_CAMPAIGN_FIND_CONTACT` - Find contact by email or ID [Prerequisite] +2. `ACTIVE_CAMPAIGN_MANAGE_CONTACT_TAG` - Add or remove tags [Required] + +**Key parameters**: +- `action`: 'Add' or 'Remove' (required) +- `tags`: Tag names as comma-separated string or array of strings (required) +- `contact_id`: Contact ID (provide this or contact_email) +- `contact_email`: Contact email address (alternative to contact_id) + +**Pitfalls**: +- `action` values are capitalized: 'Add' or 'Remove' (not lowercase) +- Tags can be a comma-separated string ('tag1, tag2') or an array (['tag1', 'tag2']) +- Either `contact_id` or `contact_email` must be provided; `contact_id` takes precedence +- Adding a tag that does not exist creates it automatically +- Removing a non-existent tag is a no-op (does not error) + +### 3. Manage List Subscriptions + +**When to use**: User wants to subscribe or unsubscribe contacts from lists + +**Tool sequence**: +1. `ACTIVE_CAMPAIGN_FIND_CONTACT` - Find the contact [Prerequisite] +2. `ACTIVE_CAMPAIGN_MANAGE_LIST_SUBSCRIPTION` - Subscribe or unsubscribe [Required] + +**Key parameters**: +- `action`: 'subscribe' or 'unsubscribe' (required) +- `list_id`: Numeric list ID string (required) +- `email`: Contact email address (provide this or contact_id) +- `contact_id`: Numeric contact ID string (alternative to email) + +**Pitfalls**: +- `action` values are lowercase: 'subscribe' or 'unsubscribe' +- `list_id` is a numeric string (e.g., '2'), not the list name +- List IDs can be retrieved via the GET /api/3/lists endpoint (not available as a Composio tool; use the ActiveCampaign UI) +- If both `email` and `contact_id` are provided, `contact_id` takes precedence +- Unsubscribing changes status to '2' (unsubscribed) but the relationship record persists + +### 4. Add Contacts to Automations + +**When to use**: User wants to enroll a contact in an automation workflow + +**Tool sequence**: +1. `ACTIVE_CAMPAIGN_FIND_CONTACT` - Verify contact exists [Prerequisite] +2. `ACTIVE_CAMPAIGN_ADD_CONTACT_TO_AUTOMATION` - Enroll contact in automation [Required] + +**Key parameters**: +- `contact_email`: Email of the contact to enroll (required) +- `automation_id`: ID of the target automation (required) + +**Pitfalls**: +- The contact must already exist in ActiveCampaign +- Automations can only be created through the ActiveCampaign UI, not via API +- `automation_id` must reference an existing, active automation +- The tool performs a two-step process: lookup contact by email, then enroll +- Automation IDs can be found in the ActiveCampaign UI or via GET /api/3/automations + +### 5. Create Contact Tasks + +**When to use**: User wants to create follow-up tasks associated with contacts + +**Tool sequence**: +1. `ACTIVE_CAMPAIGN_FIND_CONTACT` - Find the contact to associate the task with [Prerequisite] +2. `ACTIVE_CAMPAIGN_CREATE_CONTACT_TASK` - Create the task [Required] + +**Key parameters**: +- `relid`: Contact ID to associate the task with (required) +- `duedate`: Due date in ISO 8601 format with timezone (required, e.g., '2025-01-15T14:30:00-05:00') +- `dealTasktype`: Task type ID based on available types (required) +- `title`: Task title +- `note`: Task description/content +- `assignee`: User ID to assign the task to +- `edate`: End date in ISO 8601 format (must be later than duedate) +- `status`: 0 for incomplete, 1 for complete + +**Pitfalls**: +- `duedate` must be a valid ISO 8601 datetime with timezone offset; do NOT use placeholder values +- `edate` must be later than `duedate` +- `dealTasktype` is a string ID referencing task types configured in ActiveCampaign +- `relid` is the numeric contact ID, not the email address +- `assignee` is a user ID; resolve user names to IDs via the ActiveCampaign UI + +## Common Patterns + +### Contact Lookup Flow + +``` +1. Call ACTIVE_CAMPAIGN_FIND_CONTACT with email +2. If found, extract contact ID for subsequent operations +3. If not found, create contact with ACTIVE_CAMPAIGN_CREATE_CONTACT +4. Use contact ID for tags, subscriptions, or automations +``` + +### Bulk Contact Tagging + +``` +1. For each contact, call ACTIVE_CAMPAIGN_MANAGE_CONTACT_TAG +2. Use contact_email to avoid separate lookup calls +3. Batch with reasonable delays to respect rate limits +``` + +### ID Resolution + +**Contact email -> Contact ID**: +``` +1. Call ACTIVE_CAMPAIGN_FIND_CONTACT with email +2. Extract id from the response +``` + +## Known Pitfalls + +**Action Capitalization**: +- Tag actions: 'Add', 'Remove' (capitalized) +- Subscription actions: 'subscribe', 'unsubscribe' (lowercase) +- Mixing up capitalization causes errors + +**ID Types**: +- Contact IDs: numeric strings (e.g., '123') +- List IDs: numeric strings +- Automation IDs: numeric strings +- All IDs should be passed as strings, not integers + +**Automations**: +- Automations cannot be created via API; only enrollment is possible +- Automation must be active to accept new contacts +- Enrolling a contact already in the automation may have no effect + +**Rate Limits**: +- ActiveCampaign API has rate limits per account +- Implement backoff on 429 responses +- Batch operations should be spaced appropriately + +**Response Parsing**: +- Response data may be nested under `data` or `data.data` +- Parse defensively with fallback patterns +- Contact search may return multiple results; match by email for accuracy + +## Quick Reference + +| Task | Tool Slug | Key Params | +|------|-----------|------------| +| Find contact | ACTIVE_CAMPAIGN_FIND_CONTACT | email, id, phone | +| Create contact | ACTIVE_CAMPAIGN_CREATE_CONTACT | email, first_name, last_name, tags | +| Add/remove tags | ACTIVE_CAMPAIGN_MANAGE_CONTACT_TAG | action, tags, contact_email | +| Subscribe/unsubscribe | ACTIVE_CAMPAIGN_MANAGE_LIST_SUBSCRIPTION | action, list_id, email | +| Add to automation | ACTIVE_CAMPAIGN_ADD_CONTACT_TO_AUTOMATION | contact_email, automation_id | +| Create task | ACTIVE_CAMPAIGN_CREATE_CONTACT_TASK | relid, duedate, dealTasktype, title | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/addresszen-automation/SKILL.md b/plugins/awesome-claude-skills/addresszen-automation/SKILL.md new file mode 100644 index 0000000..7772925 --- /dev/null +++ b/plugins/awesome-claude-skills/addresszen-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: addresszen-automation +description: "Automate Addresszen tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Addresszen Automation via Rube MCP + +Automate Addresszen operations through Composio's Addresszen toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/addresszen](https://composio.dev/toolkits/addresszen) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Addresszen connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `addresszen` +- 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 `addresszen` +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: "Addresszen 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 Addresszen task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["addresszen"] +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 Addresszen-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `addresszen` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/adobe-automation/SKILL.md b/plugins/awesome-claude-skills/adobe-automation/SKILL.md new file mode 100644 index 0000000..e4dad77 --- /dev/null +++ b/plugins/awesome-claude-skills/adobe-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: adobe-automation +description: "Automate Adobe tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Adobe Automation via Rube MCP + +Automate Adobe operations through Composio's Adobe toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/adobe](https://composio.dev/toolkits/adobe) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Adobe connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `adobe` +- 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 `adobe` +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: "Adobe 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 Adobe task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["adobe"] +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 Adobe-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `adobe` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/adrapid-automation/SKILL.md b/plugins/awesome-claude-skills/adrapid-automation/SKILL.md new file mode 100644 index 0000000..a509990 --- /dev/null +++ b/plugins/awesome-claude-skills/adrapid-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: adrapid-automation +description: "Automate Adrapid tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Adrapid Automation via Rube MCP + +Automate Adrapid operations through Composio's Adrapid toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/adrapid](https://composio.dev/toolkits/adrapid) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Adrapid connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `adrapid` +- 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 `adrapid` +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: "Adrapid 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 Adrapid task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["adrapid"] +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 Adrapid-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `adrapid` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/adyntel-automation/SKILL.md b/plugins/awesome-claude-skills/adyntel-automation/SKILL.md new file mode 100644 index 0000000..19a3585 --- /dev/null +++ b/plugins/awesome-claude-skills/adyntel-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: adyntel-automation +description: "Automate Adyntel tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Adyntel Automation via Rube MCP + +Automate Adyntel operations through Composio's Adyntel toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/adyntel](https://composio.dev/toolkits/adyntel) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Adyntel connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `adyntel` +- 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 `adyntel` +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: "Adyntel 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 Adyntel task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["adyntel"] +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 Adyntel-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `adyntel` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/aero-workflow-automation/SKILL.md b/plugins/awesome-claude-skills/aero-workflow-automation/SKILL.md new file mode 100644 index 0000000..45292fd --- /dev/null +++ b/plugins/awesome-claude-skills/aero-workflow-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: aero-workflow-automation +description: "Automate Aero Workflow tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Aero Workflow Automation via Rube MCP + +Automate Aero Workflow operations through Composio's Aero Workflow toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/aero_workflow](https://composio.dev/toolkits/aero_workflow) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Aero Workflow connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `aero_workflow` +- 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 `aero_workflow` +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: "Aero Workflow 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 Aero Workflow task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["aero_workflow"] +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 Aero Workflow-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `aero_workflow` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/aeroleads-automation/SKILL.md b/plugins/awesome-claude-skills/aeroleads-automation/SKILL.md new file mode 100644 index 0000000..be1792a --- /dev/null +++ b/plugins/awesome-claude-skills/aeroleads-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: aeroleads-automation +description: "Automate Aeroleads tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Aeroleads Automation via Rube MCP + +Automate Aeroleads operations through Composio's Aeroleads toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/aeroleads](https://composio.dev/toolkits/aeroleads) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Aeroleads connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `aeroleads` +- 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 `aeroleads` +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: "Aeroleads 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 Aeroleads task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["aeroleads"] +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 Aeroleads-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `aeroleads` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/affinda-automation/SKILL.md b/plugins/awesome-claude-skills/affinda-automation/SKILL.md new file mode 100644 index 0000000..cbc7349 --- /dev/null +++ b/plugins/awesome-claude-skills/affinda-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: affinda-automation +description: "Automate Affinda tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Affinda Automation via Rube MCP + +Automate Affinda operations through Composio's Affinda toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/affinda](https://composio.dev/toolkits/affinda) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Affinda connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `affinda` +- 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 `affinda` +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: "Affinda 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 Affinda task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["affinda"] +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 Affinda-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `affinda` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/affinity-automation/SKILL.md b/plugins/awesome-claude-skills/affinity-automation/SKILL.md new file mode 100644 index 0000000..f043530 --- /dev/null +++ b/plugins/awesome-claude-skills/affinity-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: affinity-automation +description: "Automate Affinity tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Affinity Automation via Rube MCP + +Automate Affinity operations through Composio's Affinity toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/affinity](https://composio.dev/toolkits/affinity) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Affinity connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `affinity` +- 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 `affinity` +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: "Affinity 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 Affinity task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["affinity"] +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 Affinity-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `affinity` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/agencyzoom-automation/SKILL.md b/plugins/awesome-claude-skills/agencyzoom-automation/SKILL.md new file mode 100644 index 0000000..0e25772 --- /dev/null +++ b/plugins/awesome-claude-skills/agencyzoom-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: agencyzoom-automation +description: "Automate Agencyzoom tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Agencyzoom Automation via Rube MCP + +Automate Agencyzoom operations through Composio's Agencyzoom toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/agencyzoom](https://composio.dev/toolkits/agencyzoom) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Agencyzoom connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `agencyzoom` +- 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 `agencyzoom` +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: "Agencyzoom 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 Agencyzoom task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["agencyzoom"] +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 Agencyzoom-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `agencyzoom` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/agent-mail-automation/SKILL.md b/plugins/awesome-claude-skills/agent-mail-automation/SKILL.md new file mode 100644 index 0000000..6236ffb --- /dev/null +++ b/plugins/awesome-claude-skills/agent-mail-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: agent-mail-automation +description: "Automate Agent Mail tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Agent Mail Automation via Rube MCP + +Automate Agent Mail operations through Composio's Agent Mail toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/agent_mail](https://composio.dev/toolkits/agent_mail) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Agent Mail connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `agent_mail` +- 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 `agent_mail` +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: "Agent Mail 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 Agent Mail task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["agent_mail"] +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 Agent Mail-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `agent_mail` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/agentql-automation/SKILL.md b/plugins/awesome-claude-skills/agentql-automation/SKILL.md new file mode 100644 index 0000000..94dfa47 --- /dev/null +++ b/plugins/awesome-claude-skills/agentql-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: agentql-automation +description: "Automate Agentql tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Agentql Automation via Rube MCP + +Automate Agentql operations through Composio's Agentql toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/agentql](https://composio.dev/toolkits/agentql) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Agentql connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `agentql` +- 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 `agentql` +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: "Agentql 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 Agentql task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["agentql"] +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 Agentql-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `agentql` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/agenty-automation/SKILL.md b/plugins/awesome-claude-skills/agenty-automation/SKILL.md new file mode 100644 index 0000000..8779fa9 --- /dev/null +++ b/plugins/awesome-claude-skills/agenty-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: agenty-automation +description: "Automate Agenty tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Agenty Automation via Rube MCP + +Automate Agenty operations through Composio's Agenty toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/agenty](https://composio.dev/toolkits/agenty) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Agenty connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `agenty` +- 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 `agenty` +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: "Agenty 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 Agenty task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["agenty"] +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 Agenty-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `agenty` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/agiled-automation/SKILL.md b/plugins/awesome-claude-skills/agiled-automation/SKILL.md new file mode 100644 index 0000000..b10aa91 --- /dev/null +++ b/plugins/awesome-claude-skills/agiled-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: agiled-automation +description: "Automate Agiled tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Agiled Automation via Rube MCP + +Automate Agiled operations through Composio's Agiled toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/agiled](https://composio.dev/toolkits/agiled) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Agiled connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `agiled` +- 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 `agiled` +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: "Agiled 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 Agiled task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["agiled"] +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 Agiled-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `agiled` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/agility-cms-automation/SKILL.md b/plugins/awesome-claude-skills/agility-cms-automation/SKILL.md new file mode 100644 index 0000000..77b5ba3 --- /dev/null +++ b/plugins/awesome-claude-skills/agility-cms-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: agility-cms-automation +description: "Automate Agility CMS tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Agility CMS Automation via Rube MCP + +Automate Agility CMS operations through Composio's Agility CMS toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/agility_cms](https://composio.dev/toolkits/agility_cms) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Agility CMS connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `agility_cms` +- 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 `agility_cms` +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: "Agility CMS 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 Agility CMS task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["agility_cms"] +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 Agility CMS-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `agility_cms` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/ahrefs-automation/SKILL.md b/plugins/awesome-claude-skills/ahrefs-automation/SKILL.md new file mode 100644 index 0000000..11b4140 --- /dev/null +++ b/plugins/awesome-claude-skills/ahrefs-automation/SKILL.md @@ -0,0 +1,177 @@ +--- +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 +--- + +# Ahrefs Automation + +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) + +--- + +## Setup + +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. + +--- + +## Core Workflows + +### 1. Site Explorer Metrics + +Retrieve comprehensive SEO metrics for a domain including backlink counts, referring domains, organic keyword rankings, and traffic estimates. + +**Tool:** `AHREFS_RETRIEVE_SITE_EXPLORER_METRICS` + +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` + +Example prompt: *"Get Ahrefs site metrics for example.com as of today in the US"* + +--- + +### 2. Historical Metrics Tracking + +Track how a domain's SEO metrics have changed over time for trend analysis and competitive benchmarking. + +**Tools:** `AHREFS_RETRIEVE_SITE_EXPLORER_METRICS_HISTORY`, `AHREFS_DOMAIN_RATING_HISTORY` + +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 + +- **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 + +| 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)* diff --git a/plugins/awesome-claude-skills/ai-ml-api-automation/SKILL.md b/plugins/awesome-claude-skills/ai-ml-api-automation/SKILL.md new file mode 100644 index 0000000..2ccf6e5 --- /dev/null +++ b/plugins/awesome-claude-skills/ai-ml-api-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: ai-ml-api-automation +description: "Automate AI ML API tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# AI ML API Automation via Rube MCP + +Automate AI ML API operations through Composio's AI ML API toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/ai_ml_api](https://composio.dev/toolkits/ai_ml_api) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active AI ML API connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ai_ml_api` +- 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 `ai_ml_api` +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: "AI ML API 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 AI ML API task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["ai_ml_api"] +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 AI ML API-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ai_ml_api` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/airtable-automation/SKILL.md b/plugins/awesome-claude-skills/airtable-automation/SKILL.md new file mode 100644 index 0000000..962f534 --- /dev/null +++ b/plugins/awesome-claude-skills/airtable-automation/SKILL.md @@ -0,0 +1,175 @@ +--- +name: airtable-automation +description: "Automate Airtable tasks via Rube MCP (Composio): records, bases, tables, fields, views. Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Airtable Automation via Rube MCP + +Automate Airtable operations through Composio's Airtable toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/airtable](https://composio.dev/toolkits/airtable) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Airtable connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `airtable` +- 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 `airtable` +3. If connection is not ACTIVE, follow the returned auth link to complete Airtable auth +4. Confirm connection status shows ACTIVE before running any workflows + +## Core Workflows + +### 1. Create and Manage Records + +**When to use**: User wants to create, read, update, or delete records + +**Tool sequence**: +1. `AIRTABLE_LIST_BASES` - Discover available bases [Prerequisite] +2. `AIRTABLE_GET_BASE_SCHEMA` - Inspect table structure [Prerequisite] +3. `AIRTABLE_LIST_RECORDS` - List/filter records [Optional] +4. `AIRTABLE_CREATE_RECORD` / `AIRTABLE_CREATE_RECORDS` - Create records [Optional] +5. `AIRTABLE_UPDATE_RECORD` / `AIRTABLE_UPDATE_MULTIPLE_RECORDS` - Update records [Optional] +6. `AIRTABLE_DELETE_RECORD` / `AIRTABLE_DELETE_MULTIPLE_RECORDS` - Delete records [Optional] + +**Key parameters**: +- `baseId`: Base ID (starts with 'app', e.g., 'appXXXXXXXXXXXXXX') +- `tableIdOrName`: Table ID (starts with 'tbl') or table name +- `fields`: Object mapping field names to values +- `recordId`: Record ID (starts with 'rec') for updates/deletes +- `filterByFormula`: Airtable formula for filtering +- `typecast`: Set true for automatic type conversion + +**Pitfalls**: +- pageSize capped at 100; uses offset pagination; changing filters between pages can skip/duplicate rows +- CREATE_RECORDS hard limit of 10 records per request; chunk larger imports +- Field names are CASE-SENSITIVE and must match schema exactly +- 422 UNKNOWN_FIELD_NAME when field names are wrong; 403 for permission issues +- INVALID_MULTIPLE_CHOICE_OPTIONS may require typecast=true + +### 2. Search and Filter Records + +**When to use**: User wants to find specific records using formulas + +**Tool sequence**: +1. `AIRTABLE_GET_BASE_SCHEMA` - Verify field names and types [Prerequisite] +2. `AIRTABLE_LIST_RECORDS` - Query with filterByFormula [Required] +3. `AIRTABLE_GET_RECORD` - Get full record details [Optional] + +**Key parameters**: +- `filterByFormula`: Airtable formula (e.g., `{Status}='Done'`) +- `sort`: Array of sort objects +- `fields`: Array of field names to return +- `maxRecords`: Max total records across all pages +- `offset`: Pagination cursor from previous response + +**Pitfalls**: +- Field names in formulas must be wrapped in `{}` and match schema exactly +- String values must be quoted: `{Status}='Active'` not `{Status}=Active` +- 422 INVALID_FILTER_BY_FORMULA for bad syntax or non-existent fields +- Airtable rate limit: ~5 requests/second per base; handle 429 with Retry-After + +### 3. Manage Fields and Schema + +**When to use**: User wants to create or modify table fields + +**Tool sequence**: +1. `AIRTABLE_GET_BASE_SCHEMA` - Inspect current schema [Prerequisite] +2. `AIRTABLE_CREATE_FIELD` - Create a new field [Optional] +3. `AIRTABLE_UPDATE_FIELD` - Rename/describe a field [Optional] +4. `AIRTABLE_UPDATE_TABLE` - Update table metadata [Optional] + +**Key parameters**: +- `name`: Field name +- `type`: Field type (singleLineText, number, singleSelect, etc.) +- `options`: Type-specific options (choices for select, precision for number) +- `description`: Field description + +**Pitfalls**: +- UPDATE_FIELD only changes name/description, NOT type/options; create a replacement field and migrate +- Computed fields (formula, rollup, lookup) cannot be created via API +- 422 when type options are missing or malformed + +### 4. Manage Comments + +**When to use**: User wants to view or add comments on records + +**Tool sequence**: +1. `AIRTABLE_LIST_COMMENTS` - List comments on a record [Required] + +**Key parameters**: +- `baseId`: Base ID +- `tableIdOrName`: Table identifier +- `recordId`: Record ID (17 chars, starts with 'rec') +- `pageSize`: Comments per page (max 100) + +**Pitfalls**: +- Record IDs must be exactly 17 characters starting with 'rec' + +## Common Patterns + +### Airtable Formula Syntax + +**Comparison**: +- `{Status}='Done'` - Equals +- `{Priority}>1` - Greater than +- `{Name}!=''` - Not empty + +**Functions**: +- `AND({A}='x', {B}='y')` - Both conditions +- `OR({A}='x', {A}='y')` - Either condition +- `FIND('test', {Name})>0` - Contains text +- `IS_BEFORE({Due Date}, TODAY())` - Date comparison + +**Escape rules**: +- Single quotes in values: double them (`{Name}='John''s Company'`) + +### Pagination + +- Set `pageSize` (max 100) +- Check response for `offset` string +- Pass `offset` to next request unchanged +- Keep filters/sorts/view stable between pages + +## Known Pitfalls + +**ID Formats**: +- Base IDs: `appXXXXXXXXXXXXXX` (17 chars) +- Table IDs: `tblXXXXXXXXXXXXXX` (17 chars) +- Record IDs: `recXXXXXXXXXXXXXX` (17 chars) +- Field IDs: `fldXXXXXXXXXXXXXX` (17 chars) + +**Batch Limits**: +- CREATE_RECORDS: max 10 per request +- UPDATE_MULTIPLE_RECORDS: max 10 per request +- DELETE_MULTIPLE_RECORDS: max 10 per request + +## Quick Reference + +| Task | Tool Slug | Key Params | +|------|-----------|------------| +| List bases | AIRTABLE_LIST_BASES | (none) | +| Get schema | AIRTABLE_GET_BASE_SCHEMA | baseId | +| List records | AIRTABLE_LIST_RECORDS | baseId, tableIdOrName | +| Get record | AIRTABLE_GET_RECORD | baseId, tableIdOrName, recordId | +| Create record | AIRTABLE_CREATE_RECORD | baseId, tableIdOrName, fields | +| Create records | AIRTABLE_CREATE_RECORDS | baseId, tableIdOrName, records | +| Update record | AIRTABLE_UPDATE_RECORD | baseId, tableIdOrName, recordId, fields | +| Update records | AIRTABLE_UPDATE_MULTIPLE_RECORDS | baseId, tableIdOrName, records | +| Delete record | AIRTABLE_DELETE_RECORD | baseId, tableIdOrName, recordId | +| Create field | AIRTABLE_CREATE_FIELD | baseId, tableIdOrName, name, type | +| Update field | AIRTABLE_UPDATE_FIELD | baseId, tableIdOrName, fieldId | +| Update table | AIRTABLE_UPDATE_TABLE | baseId, tableIdOrName, name | +| List comments | AIRTABLE_LIST_COMMENTS | baseId, tableIdOrName, recordId | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/aivoov-automation/SKILL.md b/plugins/awesome-claude-skills/aivoov-automation/SKILL.md new file mode 100644 index 0000000..595479a --- /dev/null +++ b/plugins/awesome-claude-skills/aivoov-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: aivoov-automation +description: "Automate Aivoov tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Aivoov Automation via Rube MCP + +Automate Aivoov operations through Composio's Aivoov toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/aivoov](https://composio.dev/toolkits/aivoov) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Aivoov connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `aivoov` +- 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 `aivoov` +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: "Aivoov 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 Aivoov task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["aivoov"] +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 Aivoov-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `aivoov` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/alchemy-automation/SKILL.md b/plugins/awesome-claude-skills/alchemy-automation/SKILL.md new file mode 100644 index 0000000..dfc0fee --- /dev/null +++ b/plugins/awesome-claude-skills/alchemy-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: alchemy-automation +description: "Automate Alchemy tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Alchemy Automation via Rube MCP + +Automate Alchemy operations through Composio's Alchemy toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/alchemy](https://composio.dev/toolkits/alchemy) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Alchemy connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `alchemy` +- 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 `alchemy` +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: "Alchemy 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 Alchemy task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["alchemy"] +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 Alchemy-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `alchemy` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/algodocs-automation/SKILL.md b/plugins/awesome-claude-skills/algodocs-automation/SKILL.md new file mode 100644 index 0000000..24f6144 --- /dev/null +++ b/plugins/awesome-claude-skills/algodocs-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: algodocs-automation +description: "Automate Algodocs tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Algodocs Automation via Rube MCP + +Automate Algodocs operations through Composio's Algodocs toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/algodocs](https://composio.dev/toolkits/algodocs) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Algodocs connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `algodocs` +- 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 `algodocs` +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: "Algodocs 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 Algodocs task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["algodocs"] +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 Algodocs-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `algodocs` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/algolia-automation/SKILL.md b/plugins/awesome-claude-skills/algolia-automation/SKILL.md new file mode 100644 index 0000000..da6db45 --- /dev/null +++ b/plugins/awesome-claude-skills/algolia-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: algolia-automation +description: "Automate Algolia tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Algolia Automation via Rube MCP + +Automate Algolia operations through Composio's Algolia toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/algolia](https://composio.dev/toolkits/algolia) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Algolia connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `algolia` +- 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 `algolia` +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: "Algolia 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 Algolia task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["algolia"] +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 Algolia-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `algolia` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/all-images-ai-automation/SKILL.md b/plugins/awesome-claude-skills/all-images-ai-automation/SKILL.md new file mode 100644 index 0000000..a0a1a40 --- /dev/null +++ b/plugins/awesome-claude-skills/all-images-ai-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: all-images-ai-automation +description: "Automate All Images AI tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# All Images AI Automation via Rube MCP + +Automate All Images AI operations through Composio's All Images AI toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/all_images_ai](https://composio.dev/toolkits/all_images_ai) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active All Images AI connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `all_images_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. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds +2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `all_images_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 + +Always discover available tools before executing workflows: + +``` +RUBE_SEARCH_TOOLS +queries: [{use_case: "All Images AI 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 All Images AI task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["all_images_ai"] +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 All Images AI-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `all_images_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` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/alpha-vantage-automation/SKILL.md b/plugins/awesome-claude-skills/alpha-vantage-automation/SKILL.md new file mode 100644 index 0000000..77f34bd --- /dev/null +++ b/plugins/awesome-claude-skills/alpha-vantage-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: alpha-vantage-automation +description: "Automate Alpha Vantage tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Alpha Vantage Automation via Rube MCP + +Automate Alpha Vantage operations through Composio's Alpha Vantage toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/alpha_vantage](https://composio.dev/toolkits/alpha_vantage) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Alpha Vantage connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `alpha_vantage` +- 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 `alpha_vantage` +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: "Alpha Vantage 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 Alpha Vantage task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["alpha_vantage"] +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 Alpha Vantage-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `alpha_vantage` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/altoviz-automation/SKILL.md b/plugins/awesome-claude-skills/altoviz-automation/SKILL.md new file mode 100644 index 0000000..e79a144 --- /dev/null +++ b/plugins/awesome-claude-skills/altoviz-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: altoviz-automation +description: "Automate Altoviz tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Altoviz Automation via Rube MCP + +Automate Altoviz operations through Composio's Altoviz toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/altoviz](https://composio.dev/toolkits/altoviz) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Altoviz connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `altoviz` +- 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 `altoviz` +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: "Altoviz 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 Altoviz task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["altoviz"] +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 Altoviz-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `altoviz` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/alttext-ai-automation/SKILL.md b/plugins/awesome-claude-skills/alttext-ai-automation/SKILL.md new file mode 100644 index 0000000..8d17105 --- /dev/null +++ b/plugins/awesome-claude-skills/alttext-ai-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: alttext-ai-automation +description: "Automate Alttext AI tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Alttext AI Automation via Rube MCP + +Automate Alttext AI operations through Composio's Alttext AI toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/alttext_ai](https://composio.dev/toolkits/alttext_ai) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Alttext AI connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `alttext_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. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds +2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `alttext_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 + +Always discover available tools before executing workflows: + +``` +RUBE_SEARCH_TOOLS +queries: [{use_case: "Alttext AI 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 Alttext AI task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["alttext_ai"] +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 Alttext AI-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `alttext_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` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/amara-automation/SKILL.md b/plugins/awesome-claude-skills/amara-automation/SKILL.md new file mode 100644 index 0000000..8f47bfe --- /dev/null +++ b/plugins/awesome-claude-skills/amara-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: amara-automation +description: "Automate Amara tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Amara Automation via Rube MCP + +Automate Amara operations through Composio's Amara toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/amara](https://composio.dev/toolkits/amara) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Amara connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `amara` +- 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 `amara` +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: "Amara 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 Amara task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["amara"] +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 Amara-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `amara` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/amazon-automation/SKILL.md b/plugins/awesome-claude-skills/amazon-automation/SKILL.md new file mode 100644 index 0000000..06de21f --- /dev/null +++ b/plugins/awesome-claude-skills/amazon-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: amazon-automation +description: "Automate Amazon tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Amazon Automation via Rube MCP + +Automate Amazon operations through Composio's Amazon toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/amazon](https://composio.dev/toolkits/amazon) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Amazon connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `amazon` +- 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 `amazon` +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: "Amazon 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 Amazon task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["amazon"] +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 Amazon-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `amazon` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/ambee-automation/SKILL.md b/plugins/awesome-claude-skills/ambee-automation/SKILL.md new file mode 100644 index 0000000..f913081 --- /dev/null +++ b/plugins/awesome-claude-skills/ambee-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: ambee-automation +description: "Automate Ambee tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Ambee Automation via Rube MCP + +Automate Ambee operations through Composio's Ambee toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/ambee](https://composio.dev/toolkits/ambee) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Ambee connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ambee` +- 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 `ambee` +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: "Ambee 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 Ambee task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["ambee"] +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 Ambee-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ambee` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/ambient-weather-automation/SKILL.md b/plugins/awesome-claude-skills/ambient-weather-automation/SKILL.md new file mode 100644 index 0000000..e2bc525 --- /dev/null +++ b/plugins/awesome-claude-skills/ambient-weather-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: ambient-weather-automation +description: "Automate Ambient Weather tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Ambient Weather Automation via Rube MCP + +Automate Ambient Weather operations through Composio's Ambient Weather toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/ambient_weather](https://composio.dev/toolkits/ambient_weather) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Ambient Weather connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ambient_weather` +- 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 `ambient_weather` +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: "Ambient Weather 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 Ambient Weather task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["ambient_weather"] +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 Ambient Weather-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ambient_weather` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/amcards-automation/SKILL.md b/plugins/awesome-claude-skills/amcards-automation/SKILL.md new file mode 100644 index 0000000..0938670 --- /dev/null +++ b/plugins/awesome-claude-skills/amcards-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: amcards-automation +description: "Automate Amcards tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Amcards Automation via Rube MCP + +Automate Amcards operations through Composio's Amcards toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/amcards](https://composio.dev/toolkits/amcards) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Amcards connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `amcards` +- 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 `amcards` +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: "Amcards 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 Amcards task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["amcards"] +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 Amcards-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `amcards` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/amplitude-automation/SKILL.md b/plugins/awesome-claude-skills/amplitude-automation/SKILL.md new file mode 100644 index 0000000..633e1c1 --- /dev/null +++ b/plugins/awesome-claude-skills/amplitude-automation/SKILL.md @@ -0,0 +1,221 @@ +--- +name: amplitude-automation +description: "Automate Amplitude tasks via Rube MCP (Composio): events, user activity, cohorts, user identification. Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Amplitude Automation via Rube MCP + +Automate Amplitude product analytics through Composio's Amplitude toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/amplitude](https://composio.dev/toolkits/amplitude) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Amplitude connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `amplitude` +- 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 `amplitude` +3. If connection is not ACTIVE, follow the returned auth link to complete Amplitude authentication +4. Confirm connection status shows ACTIVE before running any workflows + +## Core Workflows + +### 1. Send Events + +**When to use**: User wants to track events or send event data to Amplitude + +**Tool sequence**: +1. `AMPLITUDE_SEND_EVENTS` - Send one or more events to Amplitude [Required] + +**Key parameters**: +- `events`: Array of event objects, each containing: + - `event_type`: Name of the event (e.g., 'page_view', 'purchase') + - `user_id`: Unique user identifier (required if no `device_id`) + - `device_id`: Device identifier (required if no `user_id`) + - `event_properties`: Object with custom event properties + - `user_properties`: Object with user properties to set + - `time`: Event timestamp in milliseconds since epoch + +**Pitfalls**: +- At least one of `user_id` or `device_id` is required per event +- `event_type` is required for every event; cannot be empty +- `time` must be in milliseconds (13-digit epoch), not seconds +- Batch limit applies; check schema for maximum events per request +- Events are processed asynchronously; successful API response does not mean data is immediately queryable + +### 2. Get User Activity + +**When to use**: User wants to view event history for a specific user + +**Tool sequence**: +1. `AMPLITUDE_FIND_USER` - Find user by ID or property [Prerequisite] +2. `AMPLITUDE_GET_USER_ACTIVITY` - Retrieve user's event stream [Required] + +**Key parameters**: +- `user`: Amplitude internal user ID (from FIND_USER) +- `offset`: Pagination offset for event list +- `limit`: Maximum number of events to return + +**Pitfalls**: +- `user` parameter requires Amplitude's internal user ID, NOT your application's user_id +- Must call FIND_USER first to resolve your user_id to Amplitude's internal ID +- Activity is returned in reverse chronological order by default +- Large activity histories require pagination via `offset` + +### 3. Find and Identify Users + +**When to use**: User wants to look up users or set user properties + +**Tool sequence**: +1. `AMPLITUDE_FIND_USER` - Search for a user by various identifiers [Required] +2. `AMPLITUDE_IDENTIFY` - Set or update user properties [Optional] + +**Key parameters**: +- For FIND_USER: + - `user`: Search term (user_id, email, or Amplitude ID) +- For IDENTIFY: + - `user_id`: Your application's user identifier + - `device_id`: Device identifier (alternative to user_id) + - `user_properties`: Object with `$set`, `$unset`, `$add`, `$append` operations + +**Pitfalls**: +- FIND_USER searches across user_id, device_id, and Amplitude ID +- IDENTIFY uses special property operations (`$set`, `$unset`, `$add`, `$append`) +- `$set` overwrites existing values; `$setOnce` only sets if not already set +- At least one of `user_id` or `device_id` is required for IDENTIFY +- User property changes are eventually consistent; not immediate + +### 4. Manage Cohorts + +**When to use**: User wants to list cohorts, view cohort details, or update cohort membership + +**Tool sequence**: +1. `AMPLITUDE_LIST_COHORTS` - List all saved cohorts [Required] +2. `AMPLITUDE_GET_COHORT` - Get detailed cohort information [Optional] +3. `AMPLITUDE_UPDATE_COHORT_MEMBERSHIP` - Add/remove users from a cohort [Optional] +4. `AMPLITUDE_CHECK_COHORT_STATUS` - Check async cohort operation status [Optional] + +**Key parameters**: +- For LIST_COHORTS: No required parameters +- For GET_COHORT: `cohort_id` (from list results) +- For UPDATE_COHORT_MEMBERSHIP: + - `cohort_id`: Target cohort ID + - `memberships`: Object with `add` and/or `remove` arrays of user IDs +- For CHECK_COHORT_STATUS: `request_id` from update response + +**Pitfalls**: +- Cohort IDs are required for all cohort-specific operations +- UPDATE_COHORT_MEMBERSHIP is asynchronous; use CHECK_COHORT_STATUS to verify +- `request_id` from the update response is needed for status checking +- Maximum membership changes per request may be limited; chunk large updates +- Only behavioral cohorts support API membership updates + +### 5. Browse Event Categories + +**When to use**: User wants to discover available event types and categories in Amplitude + +**Tool sequence**: +1. `AMPLITUDE_GET_EVENT_CATEGORIES` - List all event categories [Required] + +**Key parameters**: +- No required parameters; returns all configured event categories + +**Pitfalls**: +- Categories are configured in Amplitude UI; API provides read access +- Event names within categories are case-sensitive +- Use these categories to validate event_type values before sending events + +## Common Patterns + +### ID Resolution + +**Application user_id -> Amplitude internal ID**: +``` +1. Call AMPLITUDE_FIND_USER with user=your_user_id +2. Extract Amplitude's internal user ID from response +3. Use internal ID for GET_USER_ACTIVITY +``` + +**Cohort name -> Cohort ID**: +``` +1. Call AMPLITUDE_LIST_COHORTS +2. Find cohort by name in results +3. Extract id for cohort operations +``` + +### User Property Operations + +Amplitude IDENTIFY supports these property operations: +- `$set`: Set property value (overwrites existing) +- `$setOnce`: Set only if property not already set +- `$add`: Increment numeric property +- `$append`: Append to list property +- `$unset`: Remove property entirely + +Example structure: +```json +{ + "user_properties": { + "$set": {"plan": "premium", "company": "Acme"}, + "$add": {"login_count": 1} + } +} +``` + +### Async Operation Pattern + +For cohort membership updates: +``` +1. Call AMPLITUDE_UPDATE_COHORT_MEMBERSHIP -> get request_id +2. Call AMPLITUDE_CHECK_COHORT_STATUS with request_id +3. Repeat step 2 until status is 'complete' or 'error' +``` + +## Known Pitfalls + +**User IDs**: +- Amplitude has its own internal user IDs separate from your application's +- FIND_USER resolves your IDs to Amplitude's internal IDs +- GET_USER_ACTIVITY requires Amplitude's internal ID, not your user_id + +**Event Timestamps**: +- Must be in milliseconds since epoch (13 digits) +- Seconds (10 digits) will be interpreted as very old dates +- Omitting timestamp uses server receive time + +**Rate Limits**: +- Event ingestion has throughput limits per project +- Batch events where possible to reduce API calls +- Cohort membership updates have async processing limits + +**Response Parsing**: +- Response data may be nested under `data` key +- User activity returns events in reverse chronological order +- Cohort lists may include archived cohorts; check status field +- Parse defensively with fallbacks for optional fields + +## Quick Reference + +| Task | Tool Slug | Key Params | +|------|-----------|------------| +| Send events | AMPLITUDE_SEND_EVENTS | events (array) | +| Find user | AMPLITUDE_FIND_USER | user | +| Get user activity | AMPLITUDE_GET_USER_ACTIVITY | user, offset, limit | +| Identify user | AMPLITUDE_IDENTIFY | user_id, user_properties | +| List cohorts | AMPLITUDE_LIST_COHORTS | (none) | +| Get cohort | AMPLITUDE_GET_COHORT | cohort_id | +| Update cohort members | AMPLITUDE_UPDATE_COHORT_MEMBERSHIP | cohort_id, memberships | +| Check cohort status | AMPLITUDE_CHECK_COHORT_STATUS | request_id | +| List event categories | AMPLITUDE_GET_EVENT_CATEGORIES | (none) | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/anchor-browser-automation/SKILL.md b/plugins/awesome-claude-skills/anchor-browser-automation/SKILL.md new file mode 100644 index 0000000..46b9620 --- /dev/null +++ b/plugins/awesome-claude-skills/anchor-browser-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: anchor-browser-automation +description: "Automate Anchor Browser tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Anchor Browser Automation via Rube MCP + +Automate Anchor Browser operations through Composio's Anchor Browser toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/anchor_browser](https://composio.dev/toolkits/anchor_browser) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Anchor Browser connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `anchor_browser` +- 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 `anchor_browser` +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: "Anchor Browser 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 Anchor Browser task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["anchor_browser"] +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 Anchor Browser-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `anchor_browser` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/anonyflow-automation/SKILL.md b/plugins/awesome-claude-skills/anonyflow-automation/SKILL.md new file mode 100644 index 0000000..9a36d49 --- /dev/null +++ b/plugins/awesome-claude-skills/anonyflow-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: anonyflow-automation +description: "Automate Anonyflow tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Anonyflow Automation via Rube MCP + +Automate Anonyflow operations through Composio's Anonyflow toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/anonyflow](https://composio.dev/toolkits/anonyflow) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Anonyflow connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `anonyflow` +- 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 `anonyflow` +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: "Anonyflow 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 Anonyflow task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["anonyflow"] +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 Anonyflow-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `anonyflow` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/anthropic-administrator-automation/SKILL.md b/plugins/awesome-claude-skills/anthropic-administrator-automation/SKILL.md new file mode 100644 index 0000000..0d48243 --- /dev/null +++ b/plugins/awesome-claude-skills/anthropic-administrator-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: anthropic-administrator-automation +description: "Automate Anthropic Admin tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Anthropic Admin Automation via Rube MCP + +Automate Anthropic Admin operations through Composio's Anthropic Admin toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/anthropic_administrator](https://composio.dev/toolkits/anthropic_administrator) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Anthropic Admin connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `anthropic_administrator` +- 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 `anthropic_administrator` +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: "Anthropic Admin 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 Anthropic Admin task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["anthropic_administrator"] +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 Anthropic Admin-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `anthropic_administrator` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/anthropic_administrator-automation/SKILL.md b/plugins/awesome-claude-skills/anthropic_administrator-automation/SKILL.md new file mode 100644 index 0000000..588c244 --- /dev/null +++ b/plugins/awesome-claude-skills/anthropic_administrator-automation/SKILL.md @@ -0,0 +1,110 @@ +--- +name: anthropic_administrator-automation +description: "Automate Anthropic Admin tasks via Rube MCP (Composio): API keys, usage, workspaces, and organization management. Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Anthropic Admin Automation via Rube MCP + +Automate Anthropic Admin operations through Composio's Anthropic Admin toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/anthropic_administrator](https://composio.dev/toolkits/anthropic_administrator) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Anthropic Admin connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `anthropic_administrator` +- 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 `anthropic_administrator` +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": "API keys, usage, workspaces, and organization management", "known_fields": ""}] +``` + +This returns: +- Available tool slugs for Anthropic Admin +- Recommended execution plan steps +- Known pitfalls and edge cases +- Input schemas for each tool + +## Core Workflows + +### 1. Discover Available Anthropic Admin Tools + +``` +RUBE_SEARCH_TOOLS: + queries: + - use_case: "list all available Anthropic Admin tools and capabilities" +``` + +Review the returned tools, their descriptions, and input schemas before proceeding. + +### 2. Execute Anthropic Admin Operations + +After discovering tools, execute them via: + +``` +RUBE_MULTI_EXECUTE_TOOL: + tools: + - tool_slug: "" + arguments: {} + memory: {} + sync_response_to_workbench: false +``` + +### 3. Multi-Step Workflows + +For complex workflows involving multiple Anthropic Admin operations: + +1. Search for all relevant tools: `RUBE_SEARCH_TOOLS` with specific use case +2. Execute prerequisite steps first (e.g., fetch before update) +3. Pass data between steps using tool responses +4. Use `RUBE_REMOTE_WORKBENCH` for bulk operations or data processing + +## Common Patterns + +### Search Before Action +Always search for existing resources before creating new ones to avoid duplicates. + +### Pagination +Many list operations support pagination. Check responses for `next_cursor` or `page_token` and continue fetching until exhausted. + +### Error Handling +- Check tool responses for errors before proceeding +- If a tool fails, verify the connection is still ACTIVE +- Re-authenticate via `RUBE_MANAGE_CONNECTIONS` if connection expired + +### Batch Operations +For bulk operations, use `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` in a loop with `ThreadPoolExecutor` for parallel execution. + +## Known Pitfalls + +- **Always search tools first**: Tool schemas and available operations may change. Never hardcode tool slugs without first discovering them via `RUBE_SEARCH_TOOLS`. +- **Check connection status**: Ensure the Anthropic Admin connection is ACTIVE before executing any tools. Expired OAuth tokens require re-authentication. +- **Respect rate limits**: If you receive rate limit errors, reduce request frequency and implement backoff. +- **Validate schemas**: Always pass strictly schema-compliant arguments. Use `RUBE_GET_TOOL_SCHEMAS` to load full input schemas when `schemaRef` is returned instead of `input_schema`. + +## Quick Reference + +| Operation | Approach | +|-----------|----------| +| Find tools | `RUBE_SEARCH_TOOLS` with Anthropic Admin-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `anthropic_administrator` | +| 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` | + +> **Toolkit docs**: [composio.dev/toolkits/anthropic_administrator](https://composio.dev/toolkits/anthropic_administrator) diff --git a/plugins/awesome-claude-skills/apaleo-automation/SKILL.md b/plugins/awesome-claude-skills/apaleo-automation/SKILL.md new file mode 100644 index 0000000..55f44bd --- /dev/null +++ b/plugins/awesome-claude-skills/apaleo-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: apaleo-automation +description: "Automate Apaleo tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Apaleo Automation via Rube MCP + +Automate Apaleo operations through Composio's Apaleo toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/apaleo](https://composio.dev/toolkits/apaleo) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Apaleo connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apaleo` +- 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 `apaleo` +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: "Apaleo 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 Apaleo task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["apaleo"] +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 Apaleo-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apaleo` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/apex27-automation/SKILL.md b/plugins/awesome-claude-skills/apex27-automation/SKILL.md new file mode 100644 index 0000000..e94b7cd --- /dev/null +++ b/plugins/awesome-claude-skills/apex27-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: apex27-automation +description: "Automate Apex27 tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Apex27 Automation via Rube MCP + +Automate Apex27 operations through Composio's Apex27 toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/apex27](https://composio.dev/toolkits/apex27) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Apex27 connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apex27` +- 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 `apex27` +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: "Apex27 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 Apex27 task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["apex27"] +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 Apex27-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apex27` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/api-bible-automation/SKILL.md b/plugins/awesome-claude-skills/api-bible-automation/SKILL.md new file mode 100644 index 0000000..defca6e --- /dev/null +++ b/plugins/awesome-claude-skills/api-bible-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: api-bible-automation +description: "Automate API Bible tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# API Bible Automation via Rube MCP + +Automate API Bible operations through Composio's API Bible toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/api_bible](https://composio.dev/toolkits/api_bible) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active API Bible connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `api_bible` +- 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 `api_bible` +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: "API Bible 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 API Bible task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["api_bible"] +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 API Bible-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `api_bible` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/api-labz-automation/SKILL.md b/plugins/awesome-claude-skills/api-labz-automation/SKILL.md new file mode 100644 index 0000000..55c206d --- /dev/null +++ b/plugins/awesome-claude-skills/api-labz-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: api-labz-automation +description: "Automate API Labz tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# API Labz Automation via Rube MCP + +Automate API Labz operations through Composio's API Labz toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/api_labz](https://composio.dev/toolkits/api_labz) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active API Labz connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `api_labz` +- 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 `api_labz` +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: "API Labz 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 API Labz task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["api_labz"] +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 API Labz-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `api_labz` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/api-ninjas-automation/SKILL.md b/plugins/awesome-claude-skills/api-ninjas-automation/SKILL.md new file mode 100644 index 0000000..b6f20ec --- /dev/null +++ b/plugins/awesome-claude-skills/api-ninjas-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: api-ninjas-automation +description: "Automate API Ninjas tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# API Ninjas Automation via Rube MCP + +Automate API Ninjas operations through Composio's API Ninjas toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/api_ninjas](https://composio.dev/toolkits/api_ninjas) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active API Ninjas connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `api_ninjas` +- 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 `api_ninjas` +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: "API Ninjas 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 API Ninjas task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["api_ninjas"] +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 API Ninjas-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `api_ninjas` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/api-sports-automation/SKILL.md b/plugins/awesome-claude-skills/api-sports-automation/SKILL.md new file mode 100644 index 0000000..0653d97 --- /dev/null +++ b/plugins/awesome-claude-skills/api-sports-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: api-sports-automation +description: "Automate API Sports tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# API Sports Automation via Rube MCP + +Automate API Sports operations through Composio's API Sports toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/api_sports](https://composio.dev/toolkits/api_sports) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active API Sports connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `api_sports` +- 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 `api_sports` +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: "API Sports 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 API Sports task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["api_sports"] +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 API Sports-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `api_sports` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/api2pdf-automation/SKILL.md b/plugins/awesome-claude-skills/api2pdf-automation/SKILL.md new file mode 100644 index 0000000..7b44573 --- /dev/null +++ b/plugins/awesome-claude-skills/api2pdf-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: api2pdf-automation +description: "Automate Api2pdf tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Api2pdf Automation via Rube MCP + +Automate Api2pdf operations through Composio's Api2pdf toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/api2pdf](https://composio.dev/toolkits/api2pdf) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Api2pdf connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `api2pdf` +- 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 `api2pdf` +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: "Api2pdf 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 Api2pdf task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["api2pdf"] +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 Api2pdf-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `api2pdf` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/apiflash-automation/SKILL.md b/plugins/awesome-claude-skills/apiflash-automation/SKILL.md new file mode 100644 index 0000000..917efe8 --- /dev/null +++ b/plugins/awesome-claude-skills/apiflash-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: apiflash-automation +description: "Automate Apiflash tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Apiflash Automation via Rube MCP + +Automate Apiflash operations through Composio's Apiflash toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/apiflash](https://composio.dev/toolkits/apiflash) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Apiflash connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apiflash` +- 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 `apiflash` +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: "Apiflash 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 Apiflash task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["apiflash"] +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 Apiflash-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apiflash` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/apify-automation/SKILL.md b/plugins/awesome-claude-skills/apify-automation/SKILL.md new file mode 100644 index 0000000..c9954a3 --- /dev/null +++ b/plugins/awesome-claude-skills/apify-automation/SKILL.md @@ -0,0 +1,167 @@ +--- +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 +--- + +# Apify Automation + +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) + +--- + +## Setup + +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. + +--- + +## Core Workflows + +### 1. Run an Actor Synchronously and Get Results + +Execute an Actor and immediately retrieve its dataset items in a single call. Best for quick scraping jobs. + +**Tool:** `APIFY_RUN_ACTOR_SYNC_GET_DATASET_ITEMS` + +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 + +Example prompt: *"Run the Google Places scraper for 'restaurants in New York' and return the first 50 results"* + +--- + +### 2. Run an Actor Asynchronously + +Trigger an Actor run without waiting for completion. Use for long-running scraping jobs. + +**Tool:** `APIFY_RUN_ACTOR` + +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 + +- **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 + +| 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)* diff --git a/plugins/awesome-claude-skills/apilio-automation/SKILL.md b/plugins/awesome-claude-skills/apilio-automation/SKILL.md new file mode 100644 index 0000000..b8b1260 --- /dev/null +++ b/plugins/awesome-claude-skills/apilio-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: apilio-automation +description: "Automate Apilio tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Apilio Automation via Rube MCP + +Automate Apilio operations through Composio's Apilio toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/apilio](https://composio.dev/toolkits/apilio) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Apilio connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apilio` +- 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 `apilio` +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: "Apilio 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 Apilio task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["apilio"] +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 Apilio-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apilio` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/apipie-ai-automation/SKILL.md b/plugins/awesome-claude-skills/apipie-ai-automation/SKILL.md new file mode 100644 index 0000000..4162601 --- /dev/null +++ b/plugins/awesome-claude-skills/apipie-ai-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: apipie-ai-automation +description: "Automate Apipie AI tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Apipie AI Automation via Rube MCP + +Automate Apipie AI operations through Composio's Apipie AI toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/apipie_ai](https://composio.dev/toolkits/apipie_ai) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Apipie AI connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apipie_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. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds +2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `apipie_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 + +Always discover available tools before executing workflows: + +``` +RUBE_SEARCH_TOOLS +queries: [{use_case: "Apipie AI 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 Apipie AI task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["apipie_ai"] +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 Apipie AI-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apipie_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` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/apitemplate-io-automation/SKILL.md b/plugins/awesome-claude-skills/apitemplate-io-automation/SKILL.md new file mode 100644 index 0000000..0af94b5 --- /dev/null +++ b/plugins/awesome-claude-skills/apitemplate-io-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: apitemplate-io-automation +description: "Automate Apitemplate IO tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Apitemplate IO Automation via Rube MCP + +Automate Apitemplate IO operations through Composio's Apitemplate IO toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/apitemplate_io](https://composio.dev/toolkits/apitemplate_io) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Apitemplate IO connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apitemplate_io` +- 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 `apitemplate_io` +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: "Apitemplate IO 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 Apitemplate IO task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["apitemplate_io"] +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 Apitemplate IO-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apitemplate_io` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/apiverve-automation/SKILL.md b/plugins/awesome-claude-skills/apiverve-automation/SKILL.md new file mode 100644 index 0000000..076baca --- /dev/null +++ b/plugins/awesome-claude-skills/apiverve-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: apiverve-automation +description: "Automate Apiverve tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Apiverve Automation via Rube MCP + +Automate Apiverve operations through Composio's Apiverve toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/apiverve](https://composio.dev/toolkits/apiverve) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Apiverve connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `apiverve` +- 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 `apiverve` +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: "Apiverve 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 Apiverve task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["apiverve"] +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 Apiverve-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `apiverve` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/apollo-automation/SKILL.md b/plugins/awesome-claude-skills/apollo-automation/SKILL.md new file mode 100644 index 0000000..1d52a85 --- /dev/null +++ b/plugins/awesome-claude-skills/apollo-automation/SKILL.md @@ -0,0 +1,165 @@ +--- +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 +--- + +# Apollo Automation + +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) + +--- + +## Setup + +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. + +--- + +## Core Workflows + +### 1. Search Organizations +Find target companies using filters like name, location, employee count, and industry keywords. + +**Tool:** `APOLLO_ORGANIZATION_SEARCH` + +**Example prompt:** +> "Find SaaS companies in Texas with 50-500 employees on Apollo" + +**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) + +--- + +### 2. Discover People at Companies +Search Apollo's contact database for people matching title, seniority, location, and company criteria. + +**Tool:** `APOLLO_PEOPLE_SEARCH` + +**Example prompt:** +> "Find VPs of Sales at microsoft.com and apollo.io" + +**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) + +--- + +### 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 + +- **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 + +| 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)* diff --git a/plugins/awesome-claude-skills/appcircle-automation/SKILL.md b/plugins/awesome-claude-skills/appcircle-automation/SKILL.md new file mode 100644 index 0000000..6785261 --- /dev/null +++ b/plugins/awesome-claude-skills/appcircle-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: appcircle-automation +description: "Automate Appcircle tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Appcircle Automation via Rube MCP + +Automate Appcircle operations through Composio's Appcircle toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/appcircle](https://composio.dev/toolkits/appcircle) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Appcircle connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `appcircle` +- 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 `appcircle` +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: "Appcircle 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 Appcircle task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["appcircle"] +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 Appcircle-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `appcircle` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/appdrag-automation/SKILL.md b/plugins/awesome-claude-skills/appdrag-automation/SKILL.md new file mode 100644 index 0000000..6e5bb32 --- /dev/null +++ b/plugins/awesome-claude-skills/appdrag-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: appdrag-automation +description: "Automate Appdrag tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Appdrag Automation via Rube MCP + +Automate Appdrag operations through Composio's Appdrag toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/appdrag](https://composio.dev/toolkits/appdrag) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Appdrag connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `appdrag` +- 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 `appdrag` +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: "Appdrag 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 Appdrag task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["appdrag"] +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 Appdrag-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `appdrag` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/appointo-automation/SKILL.md b/plugins/awesome-claude-skills/appointo-automation/SKILL.md new file mode 100644 index 0000000..7c1171b --- /dev/null +++ b/plugins/awesome-claude-skills/appointo-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: appointo-automation +description: "Automate Appointo tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Appointo Automation via Rube MCP + +Automate Appointo operations through Composio's Appointo toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/appointo](https://composio.dev/toolkits/appointo) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Appointo connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `appointo` +- 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 `appointo` +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: "Appointo 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 Appointo task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["appointo"] +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 Appointo-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `appointo` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/appsflyer-automation/SKILL.md b/plugins/awesome-claude-skills/appsflyer-automation/SKILL.md new file mode 100644 index 0000000..b5b066e --- /dev/null +++ b/plugins/awesome-claude-skills/appsflyer-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: appsflyer-automation +description: "Automate Appsflyer tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Appsflyer Automation via Rube MCP + +Automate Appsflyer operations through Composio's Appsflyer toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/appsflyer](https://composio.dev/toolkits/appsflyer) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Appsflyer connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `appsflyer` +- 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 `appsflyer` +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: "Appsflyer 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 Appsflyer task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["appsflyer"] +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 Appsflyer-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `appsflyer` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/appveyor-automation/SKILL.md b/plugins/awesome-claude-skills/appveyor-automation/SKILL.md new file mode 100644 index 0000000..ca3a737 --- /dev/null +++ b/plugins/awesome-claude-skills/appveyor-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: appveyor-automation +description: "Automate Appveyor tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Appveyor Automation via Rube MCP + +Automate Appveyor operations through Composio's Appveyor toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/appveyor](https://composio.dev/toolkits/appveyor) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Appveyor connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `appveyor` +- 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 `appveyor` +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: "Appveyor 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 Appveyor task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["appveyor"] +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 Appveyor-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `appveyor` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/aryn-automation/SKILL.md b/plugins/awesome-claude-skills/aryn-automation/SKILL.md new file mode 100644 index 0000000..79af351 --- /dev/null +++ b/plugins/awesome-claude-skills/aryn-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: aryn-automation +description: "Automate Aryn tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Aryn Automation via Rube MCP + +Automate Aryn operations through Composio's Aryn toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/aryn](https://composio.dev/toolkits/aryn) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Aryn connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `aryn` +- 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 `aryn` +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: "Aryn 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 Aryn task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["aryn"] +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 Aryn-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `aryn` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/asana-automation/SKILL.md b/plugins/awesome-claude-skills/asana-automation/SKILL.md new file mode 100644 index 0000000..600efe5 --- /dev/null +++ b/plugins/awesome-claude-skills/asana-automation/SKILL.md @@ -0,0 +1,176 @@ +--- +name: asana-automation +description: "Automate Asana tasks via Rube MCP (Composio): tasks, projects, sections, teams, workspaces. Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Asana Automation via Rube MCP + +Automate Asana operations through Composio's Asana toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/asana](https://composio.dev/toolkits/asana) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Asana connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `asana` +- 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 `asana` +3. If connection is not ACTIVE, follow the returned auth link to complete Asana OAuth +4. Confirm connection status shows ACTIVE before running any workflows + +## Core Workflows + +### 1. Manage Tasks + +**When to use**: User wants to create, search, list, or organize tasks + +**Tool sequence**: +1. `ASANA_GET_MULTIPLE_WORKSPACES` - Get workspace ID [Prerequisite] +2. `ASANA_SEARCH_TASKS_IN_WORKSPACE` - Search tasks [Optional] +3. `ASANA_GET_TASKS_FROM_A_PROJECT` - List project tasks [Optional] +4. `ASANA_CREATE_A_TASK` - Create a new task [Optional] +5. `ASANA_GET_A_TASK` - Get task details [Optional] +6. `ASANA_CREATE_SUBTASK` - Create a subtask [Optional] +7. `ASANA_GET_TASK_SUBTASKS` - List subtasks [Optional] + +**Key parameters**: +- `workspace`: Workspace GID (required for search/creation) +- `projects`: Array of project GIDs to add task to +- `name`: Task name +- `notes`: Task description +- `assignee`: Assignee (user GID or email) +- `due_on`: Due date (YYYY-MM-DD) + +**Pitfalls**: +- Workspace GID is required for most operations; get it first +- Task GIDs are returned as strings, not integers +- Search is workspace-scoped, not project-scoped + +### 2. Manage Projects and Sections + +**When to use**: User wants to create projects, manage sections, or organize tasks + +**Tool sequence**: +1. `ASANA_GET_WORKSPACE_PROJECTS` - List workspace projects [Optional] +2. `ASANA_GET_A_PROJECT` - Get project details [Optional] +3. `ASANA_CREATE_A_PROJECT` - Create a new project [Optional] +4. `ASANA_GET_SECTIONS_IN_PROJECT` - List sections [Optional] +5. `ASANA_CREATE_SECTION_IN_PROJECT` - Create a new section [Optional] +6. `ASANA_ADD_TASK_TO_SECTION` - Move task to section [Optional] +7. `ASANA_GET_TASKS_FROM_A_SECTION` - List tasks in section [Optional] + +**Key parameters**: +- `project_gid`: Project GID +- `name`: Project or section name +- `workspace`: Workspace GID for creation +- `task`: Task GID for section assignment +- `section`: Section GID + +**Pitfalls**: +- Projects belong to workspaces; workspace GID is needed for creation +- Sections are ordered within a project +- DUPLICATE_PROJECT creates a copy with optional task inclusion + +### 3. Manage Teams and Users + +**When to use**: User wants to list teams, team members, or workspace users + +**Tool sequence**: +1. `ASANA_GET_TEAMS_IN_WORKSPACE` - List workspace teams [Optional] +2. `ASANA_GET_USERS_FOR_TEAM` - List team members [Optional] +3. `ASANA_GET_USERS_FOR_WORKSPACE` - List all workspace users [Optional] +4. `ASANA_GET_CURRENT_USER` - Get authenticated user [Optional] +5. `ASANA_GET_MULTIPLE_USERS` - Get multiple user details [Optional] + +**Key parameters**: +- `workspace_gid`: Workspace GID +- `team_gid`: Team GID + +**Pitfalls**: +- Users are workspace-scoped +- Team membership requires the team GID + +### 4. Parallel Operations + +**When to use**: User needs to perform bulk operations efficiently + +**Tool sequence**: +1. `ASANA_SUBMIT_PARALLEL_REQUESTS` - Execute multiple API calls in parallel [Required] + +**Key parameters**: +- `actions`: Array of action objects with method, path, and data + +**Pitfalls**: +- Each action must be a valid Asana API call +- Failed individual requests do not roll back successful ones + +## Common Patterns + +### ID Resolution + +**Workspace name -> GID**: +``` +1. Call ASANA_GET_MULTIPLE_WORKSPACES +2. Find workspace by name +3. Extract gid field +``` + +**Project name -> GID**: +``` +1. Call ASANA_GET_WORKSPACE_PROJECTS with workspace GID +2. Find project by name +3. Extract gid field +``` + +### Pagination + +- Asana uses cursor-based pagination with `offset` parameter +- Check for `next_page` in response +- Pass `offset` from `next_page.offset` for next request + +## Known Pitfalls + +**GID Format**: +- All Asana IDs are strings (GIDs), not integers +- GIDs are globally unique identifiers + +**Workspace Scoping**: +- Most operations require a workspace context +- Tasks, projects, and users are workspace-scoped + +## Quick Reference + +| Task | Tool Slug | Key Params | +|------|-----------|------------| +| List workspaces | ASANA_GET_MULTIPLE_WORKSPACES | (none) | +| Search tasks | ASANA_SEARCH_TASKS_IN_WORKSPACE | workspace, text | +| Create task | ASANA_CREATE_A_TASK | workspace, name, projects | +| Get task | ASANA_GET_A_TASK | task_gid | +| Create subtask | ASANA_CREATE_SUBTASK | parent, name | +| List subtasks | ASANA_GET_TASK_SUBTASKS | task_gid | +| Project tasks | ASANA_GET_TASKS_FROM_A_PROJECT | project_gid | +| List projects | ASANA_GET_WORKSPACE_PROJECTS | workspace | +| Create project | ASANA_CREATE_A_PROJECT | workspace, name | +| Get project | ASANA_GET_A_PROJECT | project_gid | +| Duplicate project | ASANA_DUPLICATE_PROJECT | project_gid | +| List sections | ASANA_GET_SECTIONS_IN_PROJECT | project_gid | +| Create section | ASANA_CREATE_SECTION_IN_PROJECT | project_gid, name | +| Add to section | ASANA_ADD_TASK_TO_SECTION | section, task | +| Section tasks | ASANA_GET_TASKS_FROM_A_SECTION | section_gid | +| List teams | ASANA_GET_TEAMS_IN_WORKSPACE | workspace_gid | +| Team members | ASANA_GET_USERS_FOR_TEAM | team_gid | +| Workspace users | ASANA_GET_USERS_FOR_WORKSPACE | workspace_gid | +| Current user | ASANA_GET_CURRENT_USER | (none) | +| Parallel requests | ASANA_SUBMIT_PARALLEL_REQUESTS | actions | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/ascora-automation/SKILL.md b/plugins/awesome-claude-skills/ascora-automation/SKILL.md new file mode 100644 index 0000000..cf10f3e --- /dev/null +++ b/plugins/awesome-claude-skills/ascora-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: ascora-automation +description: "Automate Ascora tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Ascora Automation via Rube MCP + +Automate Ascora operations through Composio's Ascora toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/ascora](https://composio.dev/toolkits/ascora) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Ascora connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ascora` +- 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 `ascora` +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: "Ascora 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 Ascora task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["ascora"] +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 Ascora-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ascora` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/ashby-automation/SKILL.md b/plugins/awesome-claude-skills/ashby-automation/SKILL.md new file mode 100644 index 0000000..78fb087 --- /dev/null +++ b/plugins/awesome-claude-skills/ashby-automation/SKILL.md @@ -0,0 +1,167 @@ +--- +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 +--- + +# Ashby Automation + +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) + +--- + +## Setup + +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 + +--- + +## Core 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` + +``` +Create a candidate named "Jane Smith" with email jane@example.com and LinkedIn profile https://linkedin.com/in/janesmith +``` + +Key parameters for `ASHBY_CREATE_CANDIDATE`: +- `name` (required) -- full name of the candidate +- `email` -- primary email address +- `phoneNumber`, `linkedInUrl`, `githubUrl`, `websiteUrl` -- contact/social profiles + +Key parameters for `ASHBY_SEARCH_CANDIDATES`: +- `email` -- exact email match +- `name` -- partial name match + +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` + +``` +Create a new "Senior Software Engineer" job in team dept-123 at location loc-456 with brand brand-789 +``` + +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` + +``` +Apply candidate cand-abc123 to job job-xyz789 with source src-referral +``` + +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` + +``` +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 + +- **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 + +| 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)* diff --git a/plugins/awesome-claude-skills/asin-data-api-automation/SKILL.md b/plugins/awesome-claude-skills/asin-data-api-automation/SKILL.md new file mode 100644 index 0000000..7c029e7 --- /dev/null +++ b/plugins/awesome-claude-skills/asin-data-api-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: asin-data-api-automation +description: "Automate Asin Data API tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Asin Data API Automation via Rube MCP + +Automate Asin Data API operations through Composio's Asin Data API toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/asin_data_api](https://composio.dev/toolkits/asin_data_api) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Asin Data API connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `asin_data_api` +- 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 `asin_data_api` +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: "Asin Data API 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 Asin Data API task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["asin_data_api"] +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 Asin Data API-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `asin_data_api` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/astica-ai-automation/SKILL.md b/plugins/awesome-claude-skills/astica-ai-automation/SKILL.md new file mode 100644 index 0000000..d134c11 --- /dev/null +++ b/plugins/awesome-claude-skills/astica-ai-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: astica-ai-automation +description: "Automate Astica AI tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Astica AI Automation via Rube MCP + +Automate Astica AI operations through Composio's Astica AI toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/astica_ai](https://composio.dev/toolkits/astica_ai) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Astica AI connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `astica_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. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds +2. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `astica_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 + +Always discover available tools before executing workflows: + +``` +RUBE_SEARCH_TOOLS +queries: [{use_case: "Astica AI 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 Astica AI task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["astica_ai"] +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 Astica AI-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `astica_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` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/async-interview-automation/SKILL.md b/plugins/awesome-claude-skills/async-interview-automation/SKILL.md new file mode 100644 index 0000000..82f3a54 --- /dev/null +++ b/plugins/awesome-claude-skills/async-interview-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: async-interview-automation +description: "Automate Async Interview tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Async Interview Automation via Rube MCP + +Automate Async Interview operations through Composio's Async Interview toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/async_interview](https://composio.dev/toolkits/async_interview) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Async Interview connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `async_interview` +- 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 `async_interview` +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: "Async Interview 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 Async Interview task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["async_interview"] +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 Async Interview-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `async_interview` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/atlassian-automation/SKILL.md b/plugins/awesome-claude-skills/atlassian-automation/SKILL.md new file mode 100644 index 0000000..5cc32a2 --- /dev/null +++ b/plugins/awesome-claude-skills/atlassian-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: atlassian-automation +description: "Automate Atlassian tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Atlassian Automation via Rube MCP + +Automate Atlassian operations through Composio's Atlassian toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/atlassian](https://composio.dev/toolkits/atlassian) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Atlassian connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `atlassian` +- 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 `atlassian` +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: "Atlassian 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 Atlassian task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["atlassian"] +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 Atlassian-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `atlassian` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/attio-automation/SKILL.md b/plugins/awesome-claude-skills/attio-automation/SKILL.md new file mode 100644 index 0000000..dd9d31f --- /dev/null +++ b/plugins/awesome-claude-skills/attio-automation/SKILL.md @@ -0,0 +1,160 @@ +--- +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 +--- + +# Attio Automation + +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) + +--- + +## Setup + +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. + +--- + +## Core Workflows + +### 1. Fuzzy Search Across Records +Search for people, companies, deals, or any object by name, domain, email, phone, or social handle. + +**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"}} +``` + +--- + +### 3. Find Records by ID or Attributes +Look up a specific record by its unique ID or search by unique attribute values. + +**Tool:** `ATTIO_FIND_RECORD` + +**Example prompt:** +> "Find the Attio company with domain example.com" + +**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 + +--- + +### 4. Browse and Filter Notes +List notes across the workspace or filter by specific parent objects and records. + +**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 + +- **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 + +| 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)* diff --git a/plugins/awesome-claude-skills/auth0-automation/SKILL.md b/plugins/awesome-claude-skills/auth0-automation/SKILL.md new file mode 100644 index 0000000..91b36d2 --- /dev/null +++ b/plugins/awesome-claude-skills/auth0-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: auth0-automation +description: "Automate Auth0 tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Auth0 Automation via Rube MCP + +Automate Auth0 operations through Composio's Auth0 toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/auth0](https://composio.dev/toolkits/auth0) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Auth0 connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `auth0` +- 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 `auth0` +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: "Auth0 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 Auth0 task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["auth0"] +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 Auth0-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `auth0` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/autobound-automation/SKILL.md b/plugins/awesome-claude-skills/autobound-automation/SKILL.md new file mode 100644 index 0000000..3cc54f4 --- /dev/null +++ b/plugins/awesome-claude-skills/autobound-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: autobound-automation +description: "Automate Autobound tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Autobound Automation via Rube MCP + +Automate Autobound operations through Composio's Autobound toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/autobound](https://composio.dev/toolkits/autobound) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Autobound connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `autobound` +- 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 `autobound` +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: "Autobound 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 Autobound task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["autobound"] +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 Autobound-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `autobound` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/autom-automation/SKILL.md b/plugins/awesome-claude-skills/autom-automation/SKILL.md new file mode 100644 index 0000000..e3bf67a --- /dev/null +++ b/plugins/awesome-claude-skills/autom-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: autom-automation +description: "Automate Autom tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Autom Automation via Rube MCP + +Automate Autom operations through Composio's Autom toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/autom](https://composio.dev/toolkits/autom) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Autom connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `autom` +- 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 `autom` +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: "Autom 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 Autom task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["autom"] +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 Autom-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `autom` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/axonaut-automation/SKILL.md b/plugins/awesome-claude-skills/axonaut-automation/SKILL.md new file mode 100644 index 0000000..39f7f28 --- /dev/null +++ b/plugins/awesome-claude-skills/axonaut-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: axonaut-automation +description: "Automate Axonaut tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Axonaut Automation via Rube MCP + +Automate Axonaut operations through Composio's Axonaut toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/axonaut](https://composio.dev/toolkits/axonaut) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Axonaut connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `axonaut` +- 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 `axonaut` +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: "Axonaut 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 Axonaut task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["axonaut"] +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 Axonaut-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `axonaut` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/ayrshare-automation/SKILL.md b/plugins/awesome-claude-skills/ayrshare-automation/SKILL.md new file mode 100644 index 0000000..f705151 --- /dev/null +++ b/plugins/awesome-claude-skills/ayrshare-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: ayrshare-automation +description: "Automate Ayrshare tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Ayrshare Automation via Rube MCP + +Automate Ayrshare operations through Composio's Ayrshare toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/ayrshare](https://composio.dev/toolkits/ayrshare) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Ayrshare connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `ayrshare` +- 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 `ayrshare` +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: "Ayrshare 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 Ayrshare task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["ayrshare"] +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 Ayrshare-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `ayrshare` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/backendless-automation/SKILL.md b/plugins/awesome-claude-skills/backendless-automation/SKILL.md new file mode 100644 index 0000000..db69aa2 --- /dev/null +++ b/plugins/awesome-claude-skills/backendless-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: backendless-automation +description: "Automate Backendless tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Backendless Automation via Rube MCP + +Automate Backendless operations through Composio's Backendless toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/backendless](https://composio.dev/toolkits/backendless) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Backendless connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `backendless` +- 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 `backendless` +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: "Backendless 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 Backendless task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["backendless"] +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 Backendless-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `backendless` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/bamboohr-automation/SKILL.md b/plugins/awesome-claude-skills/bamboohr-automation/SKILL.md new file mode 100644 index 0000000..6a25e50 --- /dev/null +++ b/plugins/awesome-claude-skills/bamboohr-automation/SKILL.md @@ -0,0 +1,225 @@ +--- +name: bamboohr-automation +description: "Automate BambooHR tasks via Rube MCP (Composio): employees, time-off, benefits, dependents, employee updates. Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# BambooHR Automation via Rube MCP + +Automate BambooHR human resources operations through Composio's BambooHR toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/bamboohr](https://composio.dev/toolkits/bamboohr) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active BambooHR connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `bamboohr` +- 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 `bamboohr` +3. If connection is not ACTIVE, follow the returned auth link to complete BambooHR authentication +4. Confirm connection status shows ACTIVE before running any workflows + +## Core Workflows + +### 1. List and Search Employees + +**When to use**: User wants to find employees or get the full employee directory + +**Tool sequence**: +1. `BAMBOOHR_GET_ALL_EMPLOYEES` - Get the employee directory [Required] +2. `BAMBOOHR_GET_EMPLOYEE` - Get detailed info for a specific employee [Optional] + +**Key parameters**: +- For GET_ALL_EMPLOYEES: No required parameters; returns directory +- For GET_EMPLOYEE: + - `id`: Employee ID (numeric) + - `fields`: Comma-separated list of fields to return (e.g., 'firstName,lastName,department,jobTitle') + +**Pitfalls**: +- Employee IDs are numeric integers +- GET_ALL_EMPLOYEES returns basic directory info; use GET_EMPLOYEE for full details +- The `fields` parameter controls which fields are returned; omitting it may return minimal data +- Common fields: firstName, lastName, department, division, jobTitle, workEmail, status +- Inactive/terminated employees may be included; check `status` field + +### 2. Track Employee Changes + +**When to use**: User wants to detect recent employee data changes for sync or auditing + +**Tool sequence**: +1. `BAMBOOHR_EMPLOYEE_GET_CHANGED` - Get employees with recent changes [Required] + +**Key parameters**: +- `since`: ISO 8601 datetime string for change detection threshold +- `type`: Type of changes to check (e.g., 'inserted', 'updated', 'deleted') + +**Pitfalls**: +- `since` parameter is required; use ISO 8601 format (e.g., '2024-01-15T00:00:00Z') +- Returns IDs of changed employees, not full employee data +- Must call GET_EMPLOYEE separately for each changed employee's details +- Useful for incremental sync workflows; cache the last sync timestamp + +### 3. Manage Time-Off + +**When to use**: User wants to view time-off balances, request time off, or manage requests + +**Tool sequence**: +1. `BAMBOOHR_GET_META_TIME_OFF_TYPES` - List available time-off types [Prerequisite] +2. `BAMBOOHR_GET_TIME_OFF_BALANCES` - Check current balances [Optional] +3. `BAMBOOHR_GET_TIME_OFF_REQUESTS` - List existing requests [Optional] +4. `BAMBOOHR_CREATE_TIME_OFF_REQUEST` - Submit a new request [Optional] +5. `BAMBOOHR_UPDATE_TIME_OFF_REQUEST` - Modify or approve/deny a request [Optional] + +**Key parameters**: +- For balances: `employeeId`, time-off type ID +- For requests: `start`, `end` (date range), `employeeId` +- For creation: + - `employeeId`: Employee to request for + - `timeOffTypeId`: Type ID from GET_META_TIME_OFF_TYPES + - `start`: Start date (YYYY-MM-DD) + - `end`: End date (YYYY-MM-DD) + - `amount`: Number of days/hours + - `notes`: Optional notes for the request +- For update: `requestId`, `status` ('approved', 'denied', 'cancelled') + +**Pitfalls**: +- Time-off type IDs are numeric; resolve via GET_META_TIME_OFF_TYPES first +- Date format is 'YYYY-MM-DD' for start and end dates +- Balances may be in hours or days depending on company configuration +- Request status updates require appropriate permissions (manager/admin) +- Creating a request does NOT auto-approve it; separate approval step needed + +### 4. Update Employee Information + +**When to use**: User wants to modify employee profile data + +**Tool sequence**: +1. `BAMBOOHR_GET_EMPLOYEE` - Get current employee data [Prerequisite] +2. `BAMBOOHR_UPDATE_EMPLOYEE` - Update employee fields [Required] + +**Key parameters**: +- `id`: Employee ID (numeric, required) +- Field-value pairs for the fields to update (e.g., `department`, `jobTitle`, `workPhone`) + +**Pitfalls**: +- Only fields included in the request are updated; others remain unchanged +- Some fields are read-only and cannot be updated via API +- Field names must match BambooHR's expected field names exactly +- Updates are audited; changes appear in the employee's change history +- Verify current values with GET_EMPLOYEE before updating to avoid overwriting + +### 5. Manage Dependents and Benefits + +**When to use**: User wants to view employee dependents or benefit coverage + +**Tool sequence**: +1. `BAMBOOHR_DEPENDENTS_GET_ALL` - List all dependents [Required] +2. `BAMBOOHR_BENEFIT_GET_COVERAGES` - Get benefit coverage details [Optional] + +**Key parameters**: +- For dependents: Optional `employeeId` filter +- For benefits: Depends on schema; check RUBE_SEARCH_TOOLS for current parameters + +**Pitfalls**: +- Dependent data includes sensitive PII; handle with appropriate care +- Benefit coverages may include multiple plan types per employee +- Not all BambooHR plans include benefits administration; check account features +- Data access depends on API key permissions + +## Common Patterns + +### ID Resolution + +**Employee name -> Employee ID**: +``` +1. Call BAMBOOHR_GET_ALL_EMPLOYEES +2. Find employee by name in directory results +3. Extract id (numeric) for detailed operations +``` + +**Time-off type name -> Type ID**: +``` +1. Call BAMBOOHR_GET_META_TIME_OFF_TYPES +2. Find type by name (e.g., 'Vacation', 'Sick Leave') +3. Extract id for time-off requests +``` + +### Incremental Sync Pattern + +For keeping external systems in sync with BambooHR: +``` +1. Store last_sync_timestamp +2. Call BAMBOOHR_EMPLOYEE_GET_CHANGED with since=last_sync_timestamp +3. For each changed employee ID, call BAMBOOHR_GET_EMPLOYEE +4. Process updates in external system +5. Update last_sync_timestamp +``` + +### Time-Off Workflow + +``` +1. GET_META_TIME_OFF_TYPES -> find type ID +2. GET_TIME_OFF_BALANCES -> verify available balance +3. CREATE_TIME_OFF_REQUEST -> submit request +4. UPDATE_TIME_OFF_REQUEST -> approve/deny (manager action) +``` + +## Known Pitfalls + +**Employee IDs**: +- Always numeric integers +- Resolve names to IDs via GET_ALL_EMPLOYEES +- Terminated employees retain their IDs + +**Date Formats**: +- Time-off dates: 'YYYY-MM-DD' +- Change detection: ISO 8601 with timezone +- Inconsistent formats between endpoints; check each endpoint's schema + +**Permissions**: +- API key permissions determine accessible fields and operations +- Some operations require admin or manager-level access +- Time-off approvals require appropriate role permissions + +**Sensitive Data**: +- Employee data includes PII (names, addresses, SSN, etc.) +- Handle all responses with appropriate security measures +- Dependent data is especially sensitive + +**Rate Limits**: +- BambooHR API has rate limits per API key +- Bulk operations should be throttled +- GET_ALL_EMPLOYEES is more efficient than individual GET_EMPLOYEE calls + +**Response Parsing**: +- Response data may be nested under `data` key +- Employee fields vary based on `fields` parameter +- Empty fields may be omitted or returned as null +- Parse defensively with fallbacks + +## Quick Reference + +| Task | Tool Slug | Key Params | +|------|-----------|------------| +| List all employees | BAMBOOHR_GET_ALL_EMPLOYEES | (none) | +| Get employee details | BAMBOOHR_GET_EMPLOYEE | id, fields | +| Track changes | BAMBOOHR_EMPLOYEE_GET_CHANGED | since, type | +| Time-off types | BAMBOOHR_GET_META_TIME_OFF_TYPES | (none) | +| Time-off balances | BAMBOOHR_GET_TIME_OFF_BALANCES | employeeId | +| List time-off requests | BAMBOOHR_GET_TIME_OFF_REQUESTS | start, end, employeeId | +| Create time-off request | BAMBOOHR_CREATE_TIME_OFF_REQUEST | employeeId, timeOffTypeId, start, end | +| Update time-off request | BAMBOOHR_UPDATE_TIME_OFF_REQUEST | requestId, status | +| Update employee | BAMBOOHR_UPDATE_EMPLOYEE | id, (field updates) | +| List dependents | BAMBOOHR_DEPENDENTS_GET_ALL | employeeId | +| Benefit coverages | BAMBOOHR_BENEFIT_GET_COVERAGES | (check schema) | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/bannerbear-automation/SKILL.md b/plugins/awesome-claude-skills/bannerbear-automation/SKILL.md new file mode 100644 index 0000000..c9c5e87 --- /dev/null +++ b/plugins/awesome-claude-skills/bannerbear-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: bannerbear-automation +description: "Automate Bannerbear tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Bannerbear Automation via Rube MCP + +Automate Bannerbear operations through Composio's Bannerbear toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/bannerbear](https://composio.dev/toolkits/bannerbear) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Bannerbear connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `bannerbear` +- 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 `bannerbear` +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: "Bannerbear 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 Bannerbear task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["bannerbear"] +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 Bannerbear-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `bannerbear` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/bart-automation/SKILL.md b/plugins/awesome-claude-skills/bart-automation/SKILL.md new file mode 100644 index 0000000..d043e09 --- /dev/null +++ b/plugins/awesome-claude-skills/bart-automation/SKILL.md @@ -0,0 +1,91 @@ +--- +name: bart-automation +description: "Automate Bart tasks via Rube MCP (Composio). Always search tools first for current schemas." +requires: + mcp: [rube] +--- + +# Bart Automation via Rube MCP + +Automate Bart operations through Composio's Bart toolkit via Rube MCP. + +**Toolkit docs**: [composio.dev/toolkits/bart](https://composio.dev/toolkits/bart) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Bart connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `bart` +- 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 `bart` +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: "Bart 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 Bart task"}] +session: {id: "existing_session_id"} +``` + +### Step 2: Check Connection + +``` +RUBE_MANAGE_CONNECTIONS +toolkits: ["bart"] +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 Bart-specific use case | +| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `bart` | +| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs | +| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` | +| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` | + +--- +*Powered by [Composio](https://composio.dev)* diff --git a/plugins/awesome-claude-skills/basecamp-automation/SKILL.md b/plugins/awesome-claude-skills/basecamp-automation/SKILL.md new file mode 100644 index 0000000..b5be28b --- /dev/null +++ b/plugins/awesome-claude-skills/basecamp-automation/SKILL.md @@ -0,0 +1,239 @@ +--- +name: basecamp-automation +description: Automate Basecamp project management, to-dos, messages, people, and to-do list organization via Rube MCP (Composio). Always search tools first for current schemas. +requires: + mcp: [rube] +--- + +# Basecamp Automation via Rube MCP + +Automate Basecamp operations including project management, to-do list creation, task management, message board posting, people management, and to-do group organization through Composio's Basecamp toolkit. + +**Toolkit docs**: [composio.dev/toolkits/basecamp](https://composio.dev/toolkits/basecamp) + +## Prerequisites + +- Rube MCP must be connected (RUBE_SEARCH_TOOLS available) +- Active Basecamp connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `basecamp` +- 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 `basecamp` +3. If connection is not ACTIVE, follow the returned auth link to complete Basecamp OAuth +4. Confirm connection status shows ACTIVE before running any workflows + +## Core Workflows + +### 1. Manage To-Do Lists and Tasks + +**When to use**: User wants to create to-do lists, add tasks, or organize work within a Basecamp project + +**Tool sequence**: +1. `BASECAMP_GET_PROJECTS` - List projects to find the target bucket_id [Prerequisite] +2. `BASECAMP_GET_BUCKETS_TODOSETS` - Get the to-do set within a project [Prerequisite] +3. `BASECAMP_GET_BUCKETS_TODOSETS_TODOLISTS` - List existing to-do lists to avoid duplicates [Optional] +4. `BASECAMP_POST_BUCKETS_TODOSETS_TODOLISTS` - Create a new to-do list in a to-do set [Required for list creation] +5. `BASECAMP_GET_BUCKETS_TODOLISTS` - Get details of a specific to-do list [Optional] +6. `BASECAMP_POST_BUCKETS_TODOLISTS_TODOS` - Create a to-do item in a to-do list [Required for task creation] +7. `BASECAMP_CREATE_TODO` - Alternative tool for creating individual to-dos [Alternative] +8. `BASECAMP_GET_BUCKETS_TODOLISTS_TODOS` - List to-dos within a to-do list [Optional] + +**Key parameters for creating to-do lists**: +- `bucket_id`: Integer project/bucket ID (from GET_PROJECTS) +- `todoset_id`: Integer to-do set ID (from GET_BUCKETS_TODOSETS) +- `name`: Title of the to-do list (required) +- `description`: HTML-formatted description (supports Rich text) + +**Key parameters for creating to-dos**: +- `bucket_id`: Integer project/bucket ID +- `todolist_id`: Integer to-do list ID +- `content`: What the to-do is for (required) +- `description`: HTML details about the to-do +- `assignee_ids`: Array of integer person IDs +- `due_on`: Due date in `YYYY-MM-DD` format +- `starts_on`: Start date in `YYYY-MM-DD` format +- `notify`: Boolean to notify assignees (defaults to false) +- `completion_subscriber_ids`: Person IDs notified upon completion + +**Pitfalls**: +- A project (bucket) can contain multiple to-do sets; selecting the wrong `todoset_id` creates lists in the wrong section +- Always check existing to-do lists before creating to avoid near-duplicate names +- Success payloads include user-facing URLs (`app_url`, `app_todos_url`); prefer returning these over raw IDs +- All IDs (`bucket_id`, `todoset_id`, `todolist_id`) are integers, not strings +- Descriptions support HTML formatting only, not Markdown + +### 2. Post and Manage Messages + +**When to use**: User wants to post messages to a project message board or update existing messages + +**Tool sequence**: +1. `BASECAMP_GET_PROJECTS` - Find the target project and bucket_id [Prerequisite] +2. `BASECAMP_GET_MESSAGE_BOARD` - Get the message board ID for the project [Prerequisite] +3. `BASECAMP_CREATE_MESSAGE` - Create a new message on the board [Required] +4. `BASECAMP_POST_BUCKETS_MESSAGE_BOARDS_MESSAGES` - Alternative message creation tool [Fallback] +5. `BASECAMP_GET_MESSAGE` - Read a specific message by ID [Optional] +6. `BASECAMP_PUT_BUCKETS_MESSAGES` - Update an existing message [Optional] + +**Key parameters**: +- `bucket_id`: Integer project/bucket ID +- `message_board_id`: Integer message board ID (from GET_MESSAGE_BOARD) +- `subject`: Message title (required) +- `content`: HTML body of the message +- `status`: Set to `"active"` to publish immediately +- `category_id`: Message type classification (optional) +- `subscriptions`: Array of person IDs to notify; omit to notify all project members + +**Pitfalls**: +- `status="draft"` can produce HTTP 400; use `status="active"` as the reliable option +- `bucket_id` and `message_board_id` must belong to the same project; mismatches fail or misroute +- Message content supports HTML tags only; not Markdown +- Updates via `PUT_BUCKETS_MESSAGES` replace the entire body -- include the full corrected content, not just a diff +- Prefer `app_url` from the response for user-facing confirmation links +- Both `CREATE_MESSAGE` and `POST_BUCKETS_MESSAGE_BOARDS_MESSAGES` do the same thing; use CREATE_MESSAGE first and fall back to POST if it fails + +### 3. Manage People and Access + +**When to use**: User wants to list people, manage project access, or add new users + +**Tool sequence**: +1. `BASECAMP_GET_PEOPLE` - List all people visible to the current user [Required] +2. `BASECAMP_GET_PROJECTS` - Find the target project [Prerequisite] +3. `BASECAMP_LIST_PROJECT_PEOPLE` - List people on a specific project [Required] +4. `BASECAMP_GET_PROJECTS_PEOPLE` - Alternative to list project members [Alternative] +5. `BASECAMP_PUT_PROJECTS_PEOPLE_USERS` - Grant or revoke project access [Required for access changes] + +**Key parameters for PUT_PROJECTS_PEOPLE_USERS**: +- `project_id`: Integer project ID +- `grant`: Array of integer person IDs to add to the project +- `revoke`: Array of integer person IDs to remove from the project +- `create`: Array of objects with `name`, `email_address`, and optional `company_name`, `title` for new users +- At least one of `grant`, `revoke`, or `create` must be provided + +**Pitfalls**: +- Person IDs are integers; always resolve names to IDs via GET_PEOPLE first +- `project_id` for people management is the same as `bucket_id` for other operations +- `LIST_PROJECT_PEOPLE` and `GET_PROJECTS_PEOPLE` are near-identical; use either +- Creating users via `create` also grants them project access in one step + +### 4. Organize To-Dos with Groups + +**When to use**: User wants to organize to-dos within a list into color-coded groups + +**Tool sequence**: +1. `BASECAMP_GET_PROJECTS` - Find the target project [Prerequisite] +2. `BASECAMP_GET_BUCKETS_TODOLISTS` - Get the to-do list details [Prerequisite] +3. `BASECAMP_GET_TODOLIST_GROUPS` - List existing groups in a to-do list [Optional] +4. `BASECAMP_GET_BUCKETS_TODOLISTS_GROUPS` - Alternative group listing [Alternative] +5. `BASECAMP_POST_BUCKETS_TODOLISTS_GROUPS` - Create a new group in a to-do list [Required] +6. `BASECAMP_CREATE_TODOLIST_GROUP` - Alternative group creation tool [Alternative] + +**Key parameters**: +- `bucket_id`: Integer project/bucket ID +- `todolist_id`: Integer to-do list ID +- `name`: Group title (required) +- `color`: Visual color identifier -- one of: `white`, `red`, `orange`, `yellow`, `green`, `blue`, `aqua`, `purple`, `gray`, `pink`, `brown` +- `status`: Filter for listing -- `"archived"` or `"trashed"` (omit for active groups) + +**Pitfalls**: +- `POST_BUCKETS_TODOLISTS_GROUPS` and `CREATE_TODOLIST_GROUP` are near-identical; use either +- Color values must be from the fixed palette; arbitrary hex/rgb values are not supported +- Groups are sub-sections within a to-do list, not standalone entities + +### 5. Browse and Inspect Projects + +**When to use**: User wants to list projects, get project details, or explore project structure + +**Tool sequence**: +1. `BASECAMP_GET_PROJECTS` - List all active projects [Required] +2. `BASECAMP_GET_PROJECT` - Get comprehensive details for a specific project [Optional] +3. `BASECAMP_GET_PROJECTS_BY_PROJECT_ID` - Alternative project detail retrieval [Alternative] + +**Key parameters**: +- `status`: Filter by `"archived"` or `"trashed"`; omit for active projects +- `project_id`: Integer project ID for detailed retrieval + +**Pitfalls**: +- Projects are sorted by most recently created first +- The response includes a `dock` array with tools (todoset, message_board, etc.) and their IDs +- Use the dock tool IDs to find `todoset_id`, `message_board_id`, etc. for downstream operations + +## Common Patterns + +### ID Resolution +Basecamp uses a hierarchical ID structure. Always resolve top-down: +- **Project (bucket_id)**: `BASECAMP_GET_PROJECTS` -- find by name, capture the `id` +- **To-do set (todoset_id)**: Found in project dock or via `BASECAMP_GET_BUCKETS_TODOSETS` +- **Message board (message_board_id)**: Found in project dock or via `BASECAMP_GET_MESSAGE_BOARD` +- **To-do list (todolist_id)**: `BASECAMP_GET_BUCKETS_TODOSETS_TODOLISTS` +- **People (person_id)**: `BASECAMP_GET_PEOPLE` or `BASECAMP_LIST_PROJECT_PEOPLE` +- Note: `bucket_id` and `project_id` refer to the same entity in different contexts + +### Pagination +Basecamp uses page-based pagination on list endpoints: +- Response headers or body may indicate more pages available +- `GET_PROJECTS`, `GET_BUCKETS_TODOSETS_TODOLISTS`, and list endpoints return paginated results +- Continue fetching until no more results are returned + +### Content Formatting +- All rich text fields use HTML, not Markdown +- Wrap content in `
` tags; use ``, ``, `