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

vestaboard-automation skill

safe

/vestaboard-automation

This skill automates Vestaboard tasks via Rube MCP by discovering tools, validating connections, and executing schemas safely.

npx playbooks add skill composiohq/awesome-claude-skills --skill vestaboard-automation

Review the files below or copy the command above to add this skill to your agents.

Files (1)

SKILL.md

2.9 KB

---
name: vestaboard-automation
description: "Automate Vestaboard tasks via Rube MCP (Composio). Always search tools first for current schemas."
requires:
  mcp: [rube]
---

# Vestaboard Automation via Rube MCP

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

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

## Prerequisites

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

### Step 2: Check Connection

```
RUBE_MANAGE_CONNECTIONS
toolkits: ["vestaboard"]
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 Vestaboard-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `vestaboard` |
| Execute | `RUBE_MULTI_EXECUTE_TOOL` with discovered tool slugs |
| Bulk ops | `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` |
| Full schema | `RUBE_GET_TOOL_SCHEMAS` for tools with `schemaRef` |

---
*Powered by [Composio](https://composio.dev)*

Overview

This skill automates Vestaboard tasks using Composio's Vestaboard toolkit via the Rube MCP. It provides a repeatable pattern for discovering current tool schemas, validating connections, and executing Vestaboard operations safely. Use it to run single updates, bulk operations, or integrate Vestaboard into larger workflows without hardcoding tool details.

How this skill works

The skill always begins by calling RUBE_SEARCH_TOOLS to retrieve the latest tool slugs and input schemas for Vestaboard operations. It then checks and ensures an active Vestaboard connection via RUBE_MANAGE_CONNECTIONS before executing any tool calls with RUBE_MULTI_EXECUTE_TOOL (including an explicit memory object). The workflow reuses session IDs, handles pagination, and can fetch full schemas with RUBE_GET_TOOL_SCHEMAS when needed.

When to use it

Updating a Vestaboard message from an external system or webhook.
Running scheduled or bulk Vestaboard updates across boards.
Integrating Vestaboard into a broader automation or alerting workflow.
When you must avoid hardcoding tool slugs or argument shapes.
When you need an auditable, schema-driven execution path for display changes.

Best practices

Always call RUBE_SEARCH_TOOLS first to get current tool slugs and input schemas.
Verify RUBE_MANAGE_CONNECTIONS shows an ACTIVE Vestaboard connection before executing tools.
Include a memory object (even {}) in RUBE_MULTI_EXECUTE_TOOL calls and reuse session IDs within a workflow.
Respect exact field names and types returned by search; never guess or hardcode schemas.
Handle pagination in search results and use RUBE_GET_TOOL_SCHEMAS for tools referenced by schemaRef.

Example use cases

Send a daily greeting message to a team Vestaboard using discovered tool and schema.
Bulk update multiple Vestaboards from CSV by iterating tool slugs returned by RUBE_SEARCH_TOOLS.
Trigger a status board update from a CI/CD pipeline when deployment completes.
Build an interactive admin UI that lists current Vestaboard tools and executes chosen actions safely.
Fallback to fetching full tool schemas when the search response includes schemaRef entries.

FAQ

Do I need API keys to use Rube MCP?

No. Add https://rube.app/mcp as an MCP server in your client configuration; the endpoint works without additional API keys.

What if RUBE_MANAGE_CONNECTIONS shows a non-ACTIVE status?

Follow the auth link returned by RUBE_MANAGE_CONNECTIONS to complete setup, then confirm the status is ACTIVE before proceeding.

Can I hardcode tool slugs and argument structures?

No. Tool schemas can change. Always call RUBE_SEARCH_TOOLS to retrieve the current slugs and exact input schema before executing tools.