What is Rube MCP and how do I start?

Rube MCP is Composio's managed control plane. Add https://rube.app/mcp as an MCP server in your client; no API keys are required. Verify availability with RUBE_SEARCH_TOOLS before use.

Do I always need to search for tool schemas before running a Fitbit tool?

Yes. The knowledge base emphasizes Always search first to obtain current tool slugs and input schemas, since schemas can change.

What if a tool schema changes or the connection status is not ACTIVE?

Re-run RUBE_SEARCH_TOOLS to get updated schemas and re-verify the connection with RUBE_MANAGE_CONNECTIONS until ACTIVE before executing any tools.

fitbit-automation

Scanned

npx machina-cli add skill ComposioHQ/awesome-claude-skills/fitbit-automation --openclaw

Files (1)

SKILL.md

2.8 KB

Fitbit Automation via Rube MCP

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

Toolkit docs: composio.dev/toolkits/fitbit

Prerequisites

Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
Active Fitbit connection via RUBE_MANAGE_CONNECTIONS with toolkit fitbit
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.

Verify Rube MCP is available by confirming RUBE_SEARCH_TOOLS responds
Call RUBE_MANAGE_CONNECTIONS with toolkit fitbit
If connection is not ACTIVE, follow the returned auth link to complete setup
Confirm connection status shows ACTIVE before running any workflows

Tool Discovery

Always discover available tools before executing workflows:

RUBE_SEARCH_TOOLS
queries: [{use_case: "Fitbit 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 Fitbit task"}]
session: {id: "existing_session_id"}

Step 2: Check Connection

RUBE_MANAGE_CONNECTIONS
toolkits: ["fitbit"]
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 Fitbit-specific use case
Connect	`RUBE_MANAGE_CONNECTIONS` with toolkit `fitbit`
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

Source

git clone https://github.com/ComposioHQ/awesome-claude-skills/blob/master/composio-skills/fitbit-automation/SKILL.mdView on GitHub

Overview

Automate Fitbit operations using Composio's Fitbit toolkit through Rube MCP. This approach emphasizes discovering current tool schemas with RUBE_SEARCH_TOOLS and ensuring an active Fitbit connection before running workflows.

How This Skill Works

You first discover available Fitbit tools with RUBE_SEARCH_TOOLS to obtain up-to-date input schemas. Next, verify the Fitbit connection via RUBE_MANAGE_CONNECTIONS and then execute the chosen tool through RUBE_MULTI_EXECUTE_TOOL, supplying exact schema-compliant arguments and a memory object. Workflows typically reuse sessions and rely on the latest tool schemas to avoid hardcoding slugs or arguments.

When to Use It

You need to automate repetitive Fitbit operations (e.g., daily data pulls, syncing, or logging) without manual steps.
You want to avoid hardcoding tool slugs or arguments by always discovering current schemas first.
You need to confirm an ACTIVE Fitbit connection before running any workflows.
You are performing batch or bulk Fitbit tasks and can leverage RUBE_REMOTE_WORKBENCH for orchestration.
You want to reuse a session across multiple Fitbit tools within a single workflow to maintain context.

Quick Start

Step 1: Ensure Rube MCP is available and call RUBE_SEARCH_TOOLS to fetch current Fitbit tool schemas.
Step 2: Call RUBE_MANAGE_CONNECTIONS with toolkit 'fitbit' and verify the connection is ACTIVE.
Step 3: Use RUBE_MULTI_EXECUTE_TOOL with the discovered tool slug and proper arguments, including memory and a session_id.

Best Practices

Always call RUBE_SEARCH_TOOLS first to get current tool schemas and avoid stale slugs.
Check that RUBE_MANAGE_CONNECTIONS shows an ACTIVE status before executing tools.
Use exact field names and types from the discovered tool schemas; avoid hardcoding.
Always include memory in RUBE_MULTI_EXECUTE_TOOL calls, even if empty.
Reuse session IDs within a workflow when appropriate; generate new ones for separate workflows.

Example Use Cases

Schedule a daily workflow that discovers Fitbit tools, then syncs today's data using the appropriate tool slug returned by RUBE_SEARCH_TOOLS.
Connect to Fitbit via RUBE_MANAGE_CONNECTIONS and execute a sequence of discovered tools to log activity and pull sleep data.
Run a bulk Fitbit operation using RUBE_REMOTE_WORKBENCH to apply multiple tooling steps across many users in one run.
Open a session, perform several sequential Fitbit tool executions, and reuse the same session to maintain context.
Handle tool schema changes gracefully by re-discovering tools before each major workflow to ensure correct arguments are used.

Frequently Asked Questions

Add this skill to your agents