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

carbone-automation skill

safe

This skill automates Carbone workflows via Rube MCP, ensuring tool schema freshness by always discovering tools before execution to streamline tasks.

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

# Carbone Automation via Rube MCP

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

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

## Prerequisites

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

### Step 2: Check Connection

```
RUBE_MANAGE_CONNECTIONS
toolkits: ["carbone"]
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 Carbone-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `carbone` |
| 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 Carbone report and template operations using Composio’s Carbone toolkit through the Rube MCP. It integrates tool discovery, connection management, and multi-step execution to run Carbone tasks reliably. The skill enforces runtime schema discovery to avoid broken executions.

How this skill works

Before any action, it calls RUBE_SEARCH_TOOLS to fetch current tool slugs, input schemas, and execution recommendations. It then verifies or establishes an active Carbone connection via RUBE_MANAGE_CONNECTIONS and runs tasks with RUBE_MULTI_EXECUTE_TOOL or RUBE_REMOTE_WORKBENCH using the discovered schemas. Each execution includes session management, memory, and pagination handling per the MCP patterns.

When to use it

Generate or manipulate Carbone reports or templates programmatically
Run bulk or remote Carbone operations as part of automated workflows
Integrate Carbone into larger Rube MCP orchestrations and pipelines
When tool schemas may change frequently or across environments
When you need guaranteed schema compliance and connection validation before execution

Best practices

Always call RUBE_SEARCH_TOOLS first; never hardcode tool slugs or argument shapes
Verify Carbone connection is ACTIVE via RUBE_MANAGE_CONNECTIONS before running tools
Pass exact fields and types returned by the search results to avoid schema errors
Always include a memory parameter (even {}) in RUBE_MULTI_EXECUTE_TOOL calls
Reuse session_id for a single workflow and generate new session IDs for new workflows
Handle pagination tokens in search and results responses until complete

Example use cases

Create or render PDF reports from templates stored in Carbone as part of an invoice pipeline
Batch-generate localized reports using RUBE_REMOTE_WORKBENCH for large datasets
Validate and update Carbone template metadata after schema discovery
Orchestrate a multi-step reporting job: discover tool, confirm connection, run rendering, store outputs
Integrate Carbone report generation into a SaaS workflow where tool schemas differ per tenant

FAQ

What is the first call I should always make?

Always call RUBE_SEARCH_TOOLS to discover current tools and their input schemas before doing anything else.

How do I know the Carbone connection is ready?

Call RUBE_MANAGE_CONNECTIONS with toolkit "carbone" and confirm the returned connection status is ACTIVE before executing tools.