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

addresszen-automation skill

safe

/addresszen-automation

This skill automates Addresszen tasks via Composio and Rube MCP, always discovering current tool schemas first to ensure accuracy.

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

# Addresszen Automation via Rube MCP

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

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

## Prerequisites

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

### Step 2: Check Connection

```
RUBE_MANAGE_CONNECTIONS
toolkits: ["addresszen"]
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 Addresszen-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `addresszen` |
| 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 Addresszen tasks using Composio's Addresszen toolkit via Rube MCP. It provides a reliable pattern for discovering tools, validating connections, and executing schema-compliant operations. The workflow emphasizes calling RUBE_SEARCH_TOOLS first and reusing session IDs for consistent runs.

How this skill works

The skill first queries RUBE_SEARCH_TOOLS to retrieve current tool slugs, input schemas, and recommended execution plans. It then verifies an active Addresszen connection via RUBE_MANAGE_CONNECTIONS and executes operations with RUBE_MULTI_EXECUTE_TOOL or RUBE_REMOTE_WORKBENCH, always passing memory and a session_id. Tool schemas and pagination tokens are respected to ensure robust, repeatable automation.

When to use it

Automate Addresszen lookups, updates, or bulk address operations
Integrate Addresszen workflows into broader agent automation pipelines
Run repeatable address-processing jobs that must follow live tool schemas
Perform bulk operations via RUBE_REMOTE_WORKBENCH with run_composio_tool()
Validate and test Addresszen flows in a controlled session-based environment

Best practices

Always call RUBE_SEARCH_TOOLS first to get current tool slugs and exact input schemas
Check RUBE_MANAGE_CONNECTIONS and ensure the Addresszen toolkit shows ACTIVE before execution
Pass the memory object in every RUBE_MULTI_EXECUTE_TOOL call, even if it's empty ({})
Reuse session_id for related operations; generate a new session for new workflows
Respect schema types and field names exactly as returned; never hardcode arguments
Handle pagination tokens and continue fetching until the dataset is complete

Example use cases

Discover available Addresszen tools for validating and normalizing addresses before saving to a CRM
Connect and verify an Addresszen session, then run bulk address standardization with RUBE_REMOTE_WORKBENCH
Execute a multi-step flow: search tools, validate connection, then call RUBE_MULTI_EXECUTE_TOOL to update addresses in batches
Automate periodic address hygiene jobs that fetch updated schemas each run to avoid breaking changes
Use session reuse to perform a sequence of related Addresszen operations with consistent context

FAQ

Do I need an API key to use Rube MCP?

No API key is required; add https://rube.app/mcp as an MCP server in your client configuration to connect.

What must I do before executing tools?

Always call RUBE_SEARCH_TOOLS to retrieve current schemas, verify Addresszen is ACTIVE via RUBE_MANAGE_CONNECTIONS, and include memory and session_id in execute calls.