home / skills / composiohq / awesome-claude-skills / api-bible-automation

api-bible-automation skill

/api-bible-automation

This skill automates API Bible tasks via Composio using Rube MCP, always discovering current tool schemas before execution.

npx playbooks add skill composiohq/awesome-claude-skills --skill api-bible-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: 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)*

Overview

This skill automates API Bible tasks using Rube MCP and Composio’s API Bible toolkit. It provides a repeatable pattern to discover tools, verify connections, and execute toolkit actions reliably. The workflow emphasizes live tool discovery and strict schema compliance to avoid runtime errors.

How this skill works

First, the skill calls RUBE_SEARCH_TOOLS to retrieve current tool slugs, input schemas, and recommended execution plans. Next, it verifies or establishes an active API Bible connection via RUBE_MANAGE_CONNECTIONS. Finally, it runs one or more tools with RUBE_MULTI_EXECUTE_TOOL (or RUBE_REMOTE_WORKBENCH for bulk tasks), always including a memory object and reusing a session ID for the workflow.

When to use it

  • Automating repeated API Bible operations like catalog queries or metadata updates
  • Running multi-step workflows that require tool discovery and dynamic schemas
  • Executing bulk transformations or remote workbench jobs against API Bible
  • Integrating API Bible tasks into larger Rube MCP orchestrations
  • When strict schema compliance is needed to avoid invalid requests

Best practices

  • Always call RUBE_SEARCH_TOOLS first to get current tool slugs and input schemas
  • Verify RUBE_MANAGE_CONNECTIONS shows ACTIVE for toolkit api_bible before executing tools
  • Include a memory object (even empty) in RUBE_MULTI_EXECUTE_TOOL calls
  • Reuse the same session_id for related steps; generate a new session for new workflows
  • Respect pagination tokens in responses and fetch until completion
  • Never hardcode field names or argument structures—use the live schema returned by search

Example use cases

  • Discover the latest API Bible endpoints and run a catalog synchronization job
  • Authenticate and run a sequence of toolkit tools to enrich API metadata
  • Perform bulk exports or imports with RUBE_REMOTE_WORKBENCH using run_composio_tool()
  • Automate paginated data retrieval from API Bible and store results in downstream systems
  • Validate and transform API Bible payloads using schemaRef from RUBE_GET_TOOL_SCHEMAS

FAQ

What is the first call I must make?

Always call RUBE_SEARCH_TOOLS to fetch the current tool list and input schemas before any execution.

What if my connection is not ACTIVE?

Use RUBE_MANAGE_CONNECTIONS with toolkit api_bible and follow the returned auth link to complete setup; confirm ACTIVE before proceeding.