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

blackboard-automation skill

safe

/blackboard-automation

This skill automates Blackboard operations via Composio's Rube MCP, automatically discovering current tool schemas and managing connections for reliable

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

# Blackboard Automation via Rube MCP

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

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

## Prerequisites

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

### Step 2: Check Connection

```
RUBE_MANAGE_CONNECTIONS
toolkits: ["blackboard"]
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 Blackboard-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `blackboard` |
| 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 Blackboard tasks by orchestrating Composio’s Blackboard toolkit through Rube MCP. It standardizes discovery, connection management, and tool execution so workflows run against the latest tool schemas. Follow the search-first pattern to avoid schema drift and ensure connection health before running actions.

How this skill works

The skill first queries RUBE_SEARCH_TOOLS to discover currently available Blackboard tools, their slugs, and input schemas. It then verifies or establishes an active Blackboard connection via RUBE_MANAGE_CONNECTIONS. Actions are executed with RUBE_MULTI_EXECUTE_TOOL (or RUBE_REMOTE_WORKBENCH for bulk jobs), always including a session_id and memory payload. The skill also handles pagination and schema lookups to build schema-compliant arguments.

When to use it

Automate course creation, enrollment, or content uploads in Blackboard
Run bulk updates or migrations against Blackboard via Composio tools
Build agent workflows that must adapt to changing tool schemas
Orchestrate multi-step Blackboard tasks requiring session state and retries
Execute scheduled Blackboard maintenance or reporting jobs

Best practices

Always call RUBE_SEARCH_TOOLS first — never hardcode tool slugs or argument shapes
Verify connection status with RUBE_MANAGE_CONNECTIONS and complete any returned auth flow until status is ACTIVE
Use the exact field names and types returned by tool discovery; validate payloads against schemaRef when available
Include a memory object (even {} ) in RUBE_MULTI_EXECUTE_TOOL calls and reuse session_id within a workflow
Handle pagination tokens and loop until complete when fetching long lists or results

Example use cases

Discover available Blackboard gradebook and roster tools, then import a CSV to update student grades
Check and refresh the Blackboard connection, then run a scheduled content sync across multiple courses
Run RUBE_MULTI_EXECUTE_TOOL to batch-create course shells and populate them with templates
Use RUBE_SEARCH_TOOLS to find a tool for enrollment changes and execute a targeted student add/drop operation
Perform a full schema fetch with RUBE_GET_TOOL_SCHEMAS before running a complex transform or migration

FAQ

Do I need API keys to use Rube MCP?

No. Add https://rube.app/mcp as an MCP server in your client configuration—no API keys are required for basic MCP access.

What if a tool schema changes during a workflow?

Always call RUBE_SEARCH_TOOLS before executing tools in a workflow. If schemas change mid-workflow, re-run discovery and adjust arguments to match the new schema.