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

google_maps-automation skill

/google_maps-automation

This skill automates Google Maps tasks via Rube MCP, ensuring up-to-date tool schemas are discovered before geocoding, directions, or place searches.

npx playbooks add skill composiohq/awesome-claude-skills --skill google_maps-automation

Review the files below or copy the command above to add this skill to your agents.

Files (1)
SKILL.md
4.1 KB
---
name: google_maps-automation
description: "Automate Google Maps tasks via Rube MCP (Composio): geocoding, directions, place search, and distance calculations. Always search tools first for current schemas."
requires:
  mcp: [rube]
---

# Google Maps Automation via Rube MCP

Automate Google Maps operations through Composio's Google Maps toolkit via Rube MCP.

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

## Prerequisites

- Rube MCP must be connected (RUBE_SEARCH_TOOLS available)
- Active Google Maps connection via `RUBE_MANAGE_CONNECTIONS` with toolkit `google_maps`
- 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 `google_maps`
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": "geocoding, directions, place search, and distance calculations", "known_fields": ""}]
```

This returns:
- Available tool slugs for Google Maps
- Recommended execution plan steps
- Known pitfalls and edge cases
- Input schemas for each tool

## Core Workflows

### 1. Discover Available Google Maps Tools

```
RUBE_SEARCH_TOOLS:
  queries:
    - use_case: "list all available Google Maps tools and capabilities"
```

Review the returned tools, their descriptions, and input schemas before proceeding.

### 2. Execute Google Maps Operations

After discovering tools, execute them via:

```
RUBE_MULTI_EXECUTE_TOOL:
  tools:
    - tool_slug: "<discovered_tool_slug>"
      arguments: {<schema-compliant arguments>}
  memory: {}
  sync_response_to_workbench: false
```

### 3. Multi-Step Workflows

For complex workflows involving multiple Google Maps operations:

1. Search for all relevant tools: `RUBE_SEARCH_TOOLS` with specific use case
2. Execute prerequisite steps first (e.g., fetch before update)
3. Pass data between steps using tool responses
4. Use `RUBE_REMOTE_WORKBENCH` for bulk operations or data processing

## Common Patterns

### Search Before Action
Always search for existing resources before creating new ones to avoid duplicates.

### Pagination
Many list operations support pagination. Check responses for `next_cursor` or `page_token` and continue fetching until exhausted.

### Error Handling
- Check tool responses for errors before proceeding
- If a tool fails, verify the connection is still ACTIVE
- Re-authenticate via `RUBE_MANAGE_CONNECTIONS` if connection expired

### Batch Operations
For bulk operations, use `RUBE_REMOTE_WORKBENCH` with `run_composio_tool()` in a loop with `ThreadPoolExecutor` for parallel execution.

## Known Pitfalls

- **Always search tools first**: Tool schemas and available operations may change. Never hardcode tool slugs without first discovering them via `RUBE_SEARCH_TOOLS`.
- **Check connection status**: Ensure the Google Maps connection is ACTIVE before executing any tools. Expired OAuth tokens require re-authentication.
- **Respect rate limits**: If you receive rate limit errors, reduce request frequency and implement backoff.
- **Validate schemas**: Always pass strictly schema-compliant arguments. Use `RUBE_GET_TOOL_SCHEMAS` to load full input schemas when `schemaRef` is returned instead of `input_schema`.

## Quick Reference

| Operation | Approach |
|-----------|----------|
| Find tools | `RUBE_SEARCH_TOOLS` with Google Maps-specific use case |
| Connect | `RUBE_MANAGE_CONNECTIONS` with toolkit `google_maps` |
| 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` |

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

Overview

This skill automates Google Maps tasks through Rube MCP (Composio) to perform geocoding, directions, place search, and distance calculations. It guides tool discovery, connection management, and multi-step execution so agents can run reliable location workflows. The workflow emphasizes searching tools first and validating connection status before executing actions.

How this skill works

The skill uses RUBE_SEARCH_TOOLS to discover current Google Maps tool slugs, input schemas, and recommended execution plans. After discovery, it runs operations with RUBE_MULTI_EXECUTE_TOOL and coordinates complex or bulk jobs via RUBE_REMOTE_WORKBENCH. It always validates connection status via RUBE_MANAGE_CONNECTIONS and fetches full tool schemas when schemaRef is returned.

When to use it

  • Automate geocoding or reverse geocoding at scale
  • Generate directions or route optimizations across many waypoints
  • Search for places and fetch place details programmatically
  • Compute distances and travel times between multiple locations
  • Batch or parallelize Google Maps queries using the remote workbench

Best practices

  • Always call RUBE_SEARCH_TOOLS first to get current tool slugs and input schemas
  • Verify Google Maps connection is ACTIVE via RUBE_MANAGE_CONNECTIONS before executing tools
  • Use RUBE_GET_TOOL_SCHEMAS if a schemaRef is returned to validate inputs exactly
  • Handle pagination by checking next_cursor or page_token and iterate until exhausted
  • Respect rate limits: implement retry/backoff and reduce concurrency on 429 errors

Example use cases

  • Look up coordinates for a list of addresses, then compute optimized driving distances between them
  • Search nearby places for each coordinate and aggregate place details in bulk using RUBE_REMOTE_WORKBENCH
  • Build a multi-step flow: geocode addresses, get directions, then compute total travel time for route planning
  • Automate place search and deduplicate results by searching before creating new entries
  • Parallelize large batches of distance calculations with ThreadPoolExecutor inside RUBE_REMOTE_WORKBENCH

FAQ

Do I need API keys to use Rube MCP with Google Maps?

No API keys are required for Rube MCP itself; add the MCP server endpoint and set up the google_maps connection via RUBE_MANAGE_CONNECTIONS, then follow the auth link if needed.

What should I do if a tool schema changes?

Always re-run RUBE_SEARCH_TOOLS to discover current schemas and call RUBE_GET_TOOL_SCHEMAS for full input definitions before executing any tooling.