Make Automation

1---
2name: make-automation
3description: "Automate Make (Integromat) tasks via Rube MCP (Composio): operations, enums, language and timezone lookups. Always search tools first for current schemas."
4requires:
5  mcp: [rube]
6---
7 
8# Make Automation via Rube MCP
9 
10Automate Make (formerly Integromat) operations through Composio's Make toolkit via Rube MCP.
11 
12## Prerequisites
13 
14- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
15- Active Make connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `make`
16- Always call `RUBE_SEARCH_TOOLS` first to get current tool schemas
17 
18## Setup
19 
20**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.
21 
22 
231. Verify Rube MCP is available by confirming `RUBE_SEARCH_TOOLS` responds
242. Call `RUBE_MANAGE_CONNECTIONS` with toolkit `make`
253. If connection is not ACTIVE, follow the returned auth link to complete Make authentication
264. Confirm connection status shows ACTIVE before running any workflows
27 
28## Core Workflows
29 
30### 1. Get Operations Data
31 
32**When to use**: User wants to retrieve operation logs or usage data from Make scenarios
33 
34**Tool sequence**:
351. `MAKE_GET_OPERATIONS` - Retrieve operation records [Required]
36 
37**Key parameters**:
38- Check current schema via RUBE_SEARCH_TOOLS for available filters
39- May include date range, scenario ID, or status filters
40 
41**Pitfalls**:
42- Operations data may be paginated; check for pagination tokens
43- Date filters must match expected format from schema
44- Large result sets should be filtered by date range or scenario
45 
46### 2. List Available Languages
47 
48**When to use**: User wants to see supported languages for Make scenarios or interfaces
49 
50**Tool sequence**:
511. `MAKE_LIST_ENUMS_LANGUAGES` - Get all supported language codes [Required]
52 
53**Key parameters**:
54- No required parameters; returns complete language list
55 
56**Pitfalls**:
57- Language codes follow standard locale format (e.g., 'en', 'fr', 'de')
58- List is static and rarely changes; cache results when possible
59 
60### 3. List Available Timezones
61 
62**When to use**: User wants to see supported timezones for scheduling Make scenarios
63 
64**Tool sequence**:
651. `MAKE_LIST_ENUMS_TIMEZONES` - Get all supported timezone identifiers [Required]
66 
67**Key parameters**:
68- No required parameters; returns complete timezone list
69 
70**Pitfalls**:
71- Timezone identifiers use IANA format (e.g., 'America/New_York', 'Europe/London')
72- List is static and rarely changes; cache results when possible
73- Use these exact timezone strings when configuring scenario schedules
74 
75### 4. Scenario Configuration Lookup
76 
77**When to use**: User needs to configure scenarios with correct language and timezone values
78 
79**Tool sequence**:
801. `MAKE_LIST_ENUMS_LANGUAGES` - Get valid language codes [Required]
812. `MAKE_LIST_ENUMS_TIMEZONES` - Get valid timezone identifiers [Required]
82 
83**Key parameters**:
84- No parameters needed for either call
85 
86**Pitfalls**:
87- Always verify language and timezone values against these enums before using in configuration
88- Using invalid values in scenario configuration will cause errors
89 
90## Common Patterns
91 
92### Enum Validation
93 
94Before configuring any Make scenario properties that accept language or timezone:
95```
961. Call MAKE_LIST_ENUMS_LANGUAGES or MAKE_LIST_ENUMS_TIMEZONES
972. Verify the desired value exists in the returned list
983. Use the exact string value from the enum list
99```
100 
101### Operations Monitoring
102 
103```
1041. Call MAKE_GET_OPERATIONS with date range filters
1052. Analyze operation counts, statuses, and error rates
1063. Identify failed operations for troubleshooting
107```
108 
109### Caching Strategy for Enums
110 
111Since language and timezone lists are static:
112```
1131. Call MAKE_LIST_ENUMS_LANGUAGES once at workflow start
1142. Store results in memory or local cache
1153. Validate user inputs against cached values
1164. Refresh cache only when starting a new session
117```
118 
119### Operations Analysis Workflow
120 
121For scenario health monitoring:
122```
1231. Call MAKE_GET_OPERATIONS with recent date range
1242. Group operations by scenario ID
1253. Calculate success/failure ratios per scenario
1264. Identify scenarios with high error rates
1275. Report findings to user or notification channel
128```
129 
130### Integration with Other Toolkits
131 
132Make workflows often connect to other apps. Compose multi-tool workflows:
133```
1341. Call RUBE_SEARCH_TOOLS to find tools for the target app
1352. Connect required toolkits via RUBE_MANAGE_CONNECTIONS
1363. Use Make operations data to understand workflow execution patterns
1374. Execute equivalent workflows directly via individual app toolkits
138```
139 
140## Known Pitfalls
141 
142**Limited Toolkit**:
143- The Make toolkit in Composio currently has limited tools (operations, languages, timezones)
144- For full scenario management (creating, editing, running scenarios), consider using Make's native API
145- Always call RUBE_SEARCH_TOOLS to check for newly available tools
146- The toolkit may be expanded over time; re-check periodically
147 
148**Operations Data**:
149- Operation records may have significant volume for active accounts
150- Always filter by date range to avoid fetching excessive data
151- Operation counts relate to Make's pricing tiers and quota usage
152- Failed operations should be investigated; they may indicate scenario configuration issues
153 
154**Response Parsing**:
155- Response data may be nested under `data` key
156- Enum lists return arrays of objects with code and label fields
157- Operations data includes nested metadata about scenario execution
158- Parse defensively with fallbacks for optional fields
159 
160**Rate Limits**:
161- Make API has rate limits per API token
162- Avoid rapid repeated calls to the same endpoint
163- Cache enum results (languages, timezones) as they rarely change
164- Operations queries should use targeted date ranges
165 
166**Authentication**:
167- Make API uses token-based authentication
168- Tokens may have different permission scopes
169- Some operations data may be restricted based on token scope
170- Check that the authenticated user has access to the target organization
171 
172## Quick Reference
173 
174| Task | Tool Slug | Key Params |
175|------|-----------|------------|
176| Get operations | MAKE_GET_OPERATIONS | (check schema for filters) |
177| List languages | MAKE_LIST_ENUMS_LANGUAGES | (none) |
178| List timezones | MAKE_LIST_ENUMS_TIMEZONES | (none) |
179 
180## Additional Notes
181 
182### Alternative Approaches
183 
184Since the Make toolkit has limited tools, consider these alternatives for common Make use cases:
185 
186| Make Use Case | Alternative Approach |
187|--------------|---------------------|
188| Trigger a scenario | Use Make's native webhook or API endpoint directly |
189| Create a scenario | Use Make's scenario management API directly |
190| Schedule execution | Use RUBE_MANAGE_RECIPE_SCHEDULE with composed workflows |
191| Multi-app workflow | Compose individual toolkit tools via RUBE_MULTI_EXECUTE_TOOL |
192| Data transformation | Use RUBE_REMOTE_WORKBENCH for complex processing |
193 
194### Composing Equivalent Workflows
195 
196Instead of relying solely on Make's toolkit, build equivalent automation directly:
1971. Identify the apps involved in your Make scenario
1982. Search for each app's tools via RUBE_SEARCH_TOOLS
1993. Connect all required toolkits
2004. Build the workflow step-by-step using individual app tools
2015. Save as a recipe via RUBE_CREATE_UPDATE_RECIPE for reuse
202