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

algolia-automation skill

safe

/algolia-automation

This skill automates Algolia tasks through Rube MCP, ensuring tool schemas stay current by querying search tools before execution.

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

# Algolia Automation via Rube MCP

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

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

## Prerequisites

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

### Step 2: Check Connection

```
RUBE_MANAGE_CONNECTIONS
toolkits: ["algolia"]
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 Algolia-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `algolia` |
| 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 Algolia tasks through Composio's Algolia toolkit using Rube MCP. It streamlines discovery, connection checks, and execution of Algolia operations while enforcing schema compliance and session handling. It is designed for programmatic workflows that interact with Algolia via Rube MCP.

How this skill works

The skill first calls RUBE_SEARCH_TOOLS to fetch current tool slugs, input schemas, and recommended execution plans. It then verifies an active Algolia connection using RUBE_MANAGE_CONNECTIONS and runs operations via RUBE_MULTI_EXECUTE_TOOL or RUBE_REMOTE_WORKBENCH, always supplying memory and a session_id. It enforces using returned schema fields exactly and handles pagination and session reuse for robust workflows.

When to use it

When you need to automate index creation, updates, or searches in Algolia.
When integrating Algolia operations into Claude or other agent workflows via Rube MCP.
When multiple Algolia tools or versions may be available and you must discover current schemas first.
When running bulk operations or remote workbench tasks against Algolia.
When you need reliable session and connection validation before executing actions.

Best practices

Always call RUBE_SEARCH_TOOLS first; never hardcode tool slugs or argument shapes.
Use RUBE_MANAGE_CONNECTIONS to confirm the Algolia connection status is ACTIVE before execution.
Pass memory (even if {}) and a consistent session_id to RUBE_MULTI_EXECUTE_TOOL calls; generate new session_ids per new workflow.
Follow the exact field names and types returned by tool discovery to avoid schema errors.
Check responses for pagination tokens and iterate until you’ve retrieved complete result sets.

Example use cases

Discover available Algolia tool endpoints and schemas before building a search UI integration.
Validate and activate Algolia connections programmatically during deployment checks.
Batch-update records across indexes using RUBE_MULTI_EXECUTE_TOOL with schema-compliant arguments.
Run bulk import or reindex jobs via RUBE_REMOTE_WORKBENCH and run_composio_tool().
Implement automated workflows that run incremental syncs and handle pagination safely.

FAQ

What must I call first when using this skill?

Always run RUBE_SEARCH_TOOLS to discover the current tool slugs and input schemas before any other calls.

What if connection status is not ACTIVE?

Call RUBE_MANAGE_CONNECTIONS with toolkit 'algolia' and follow the returned auth link to complete setup; confirm ACTIVE before executing tools.