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

alchemy-automation skill

safe

/alchemy-automation

This skill automates Alchemy tasks via Rube MCP by discovering current tool schemas first and executing tools securely.

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

# Alchemy Automation via Rube MCP

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

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

## Prerequisites

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

### Step 2: Check Connection

```
RUBE_MANAGE_CONNECTIONS
toolkits: ["alchemy"]
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 Alchemy-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `alchemy` |
| 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 Alchemy operations by driving Composio's Alchemy toolkit through the Rube MCP. It provides a clear workflow for discovering available tools, validating connections, and executing multi-step Alchemy tasks programmatically. The skill emphasizes always querying tool schemas first to avoid breaking changes and ensures reliable session and memory handling.

How this skill works

First, call RUBE_SEARCH_TOOLS to retrieve current tool slugs, input schemas, and recommended plans for your Alchemy use case. Next, verify the Alchemy connection status via RUBE_MANAGE_CONNECTIONS and follow any returned auth links until the connection is ACTIVE. Finally, execute toolkit actions with RUBE_MULTI_EXECUTE_TOOL (including a memory object and valid session_id) or use RUBE_REMOTE_WORKBENCH for bulk operations and run_composio_tool().

When to use it

Automating token, transaction, or data queries against Alchemy programmatically.
Orchestrating multi-step blockchain workflows that rely on Composio Alchemy tools.
Building repeatable workflows where tool schemas may change over time.
Running bulk or parallel Alchemy operations using remote workbench capabilities.
Embedding Alchemy operations inside larger Claude AI agent workflows.

Best practices

Always call RUBE_SEARCH_TOOLS before using any tool; never hardcode tool slugs or argument shapes.
Confirm RUBE_MANAGE_CONNECTIONS shows toolkit 'alchemy' as ACTIVE before executing tools.
Include an explicit memory object ({} if empty) in every RUBE_MULTI_EXECUTE_TOOL call.
Reuse session_id for a single workflow; generate new session IDs for separate workflows.
Check responses for pagination tokens and fetch until complete when listing tools or results.

Example use cases

Discover available Alchemy endpoints and run a multi-step workflow to fetch and aggregate on-chain data.
Connect and authenticate an Alchemy toolkit, then execute a batch of transactions via RUBE_MULTI_EXECUTE_TOOL.
Automate periodic data captures from Alchemy and store results through a remote workbench bulk job.
Validate schema changes by fetching full tool schemas with RUBE_GET_TOOL_SCHEMAS before running updates.

FAQ

What is the first call I should make every time?

Always run RUBE_SEARCH_TOOLS to fetch current tool slugs and input schemas before any other operation.

Do I need API keys to use Rube MCP?

No API keys are required for the MCP endpoint; add https://rube.app/mcp to your client configuration and follow connection steps.