SIGN UPLOG IN
X (Twitter)LinkedInGitHubDiscordYouTube

How to integrate Google Maps MCP with Claude Agent SDK

Connect Claude Agent SDK to Google Maps MCP. Find walking directions from your hotel to conference center, show top-rated coffee shops near your location, and more using natural language, with authentication handled for you.

Get started for freeGet a demo
Google Maps logoGoogle Maps
Oauth2Api Key

Google Maps is a leading mapping and geolocation service for finding locations, routes, and businesses worldwide. It helps users access real-time navigation, geocoding, and mapping data for seamless location-based experiences.

20 Tools

Introduction

This guide walks you through connecting Google Maps to the Claude Agent SDK using the Composio tool router. By the end, you'll have a working Google Maps agent that can search places, get routes and route matrices, geocode addresses, fetch place details and photos, and check time zones through natural language commands.

This guide will help you understand how to give your Claude Agent SDK agent real control over a Google Maps account through Composio's Google Maps MCP server.

Before we dive in, let's take a quick look at the key ideas and tools involved.

For exact tool slugs and parameter tables, see the tool catalog in the Composio docs.

Also integrate Google Maps with

Claude CodeCursorChatGPTClaude CoworkAntigravityOpenAI Agents SDKGrok BotMuseCodexGrok BuildVS CodeOpenCodeOpenClawHermesAtomic AgentPiDeepSeek HarnessGoogle ADKLangChainVercel AI SDKMastra AILlamaIndexCrewAIPydantic AIAutoGen

TL;DR

Here's what you'll learn:
  • Get and set up your Claude/Anthropic and Composio API keys
  • Install the necessary dependencies
  • Initialize Composio and create a Tool Router session for Google Maps
  • Configure an AI agent that can use Google Maps as a tool
  • Run a live chat session where you can ask the agent to perform Google Maps operations

What is Claude Agent SDK?

The Claude Agent SDK is Anthropic's official framework for building AI agents powered by Claude. It provides a streamlined interface for creating agents with MCP tool support and conversation management.

Key features include:

  • Native MCP Support: Built-in support for Model Context Protocol servers
  • Permission Modes: Control tool execution permissions
  • Streaming Responses: Real-time response streaming for interactive applications
  • Context Manager: Clean async context management for sessions

What is the Google Maps MCP server, and what's possible with it?

The Google Maps MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Google Maps account. It provides structured and secure access to place and location data, so your agent can search for places, geocode addresses, compare travel times, retrieve place details, and create map content on your behalf.

  • Place search and suggestions: Have your agent find places from natural language searches or suggest matching locations as you type.
  • Address and coordinate lookup: Let the agent convert addresses into coordinates, turn coordinates into readable addresses, or look up a location from a known place.
  • Travel distance and time comparison: Direct your agent to compare travel distances and durations across multiple starting points and destinations using different travel modes.
  • Place details, photos, and time zones: Instruct your agent to retrieve useful place information, fetch location photos, or identify the time zone for specific coordinates.
  • Maps and aerial content: Have your agent generate an embeddable Google Map or request an aerial view video for a US postal address.

What is the Composio tool router, and how does it fit here?

What is Composio SDK?

Composio's Composio SDK helps agents find the right tools for a task at runtime. You can plug in multiple toolkits (like Gmail, HubSpot, and GitHub), and the agent will identify the relevant app and action to complete multi-step workflows. This can reduce token usage and improve the reliability of tool calls. Read more here: Getting started with Composio SDK

The tool router generates a secure MCP URL that your agents can access to perform actions.

How the Composio SDK works

The Composio SDK follows a three-phase workflow:

  1. Discovery: Searches for tools matching your task and returns relevant toolkits with their details.
  2. Authentication: Checks for active connections. If missing, creates an auth config and returns a connection URL via Auth Link.
  3. Execution: Executes the action using the authenticated connection.

Step-by-step Guide

Step by step09 STEPS
1

Prerequisites

Before starting, make sure you have:
  • Composio API Key and Claude/Anthropic API Key
  • Primary know-how of Claude Agents SDK
  • A Google Maps account
  • Some knowledge of Python
2

Getting API Keys for Claude/Anthropic and Composio

Claude/Anthropic API Key
  • Go to the Anthropic Console and create an API key. You'll need credits to use the models.
  • Keep the API key safe.
Composio API Key
  • Log in to the Composio dashboard.
  • Navigate to your API settings and generate a new API key.
  • Store this key securely as you'll need it for authentication.
3

Install dependencies

npm install @anthropic-ai/claude-agent-sdk @composio/core dotenv

Install the Composio SDK and the Claude Agents SDK.

What's happening:

  • @composio/core provides Composio integration for Anthropic
  • @anthropic-ai/claude-agent-sdk is the core agent framework
  • dotenv/config loads environment variables
4

Set up environment variables

bash
COMPOSIO_API_KEY=your_composio_api_key_here
USER_ID=your_user_id_here
ANTHROPIC_API_KEY=your_anthropic_api_key_here

Create a .env file in your project root.

What's happening:

  • COMPOSIO_API_KEY authenticates with Composio
  • USER_ID identifies the user for session management
  • ANTHROPIC_API_KEY authenticates with Anthropic/Claude
5

Import dependencies

import 'dotenv/config';
import readline from 'node:readline';
import { Composio } from '@composio/core';
import { query, type Options } from "@anthropic-ai/claude-agent-sdk";

dotenv.config();
What's happening:
  • We're importing all necessary libraries including the Claude Agent SDK and Composio
  • The dotenv.config() function loads environment variables from your .env file
  • This setup prepares the foundation for connecting Claude with Google Maps functionality
6

Create a Composio instance and Tool Router session

async function chat() {
  const { COMPOSIO_API_KEY, USER_ID } = process.env;
  if (!COMPOSIO_API_KEY || !USER_ID) {
    throw new Error('COMPOSIO_API_KEY and USER_ID required in .env');
  }

  const composio = new Composio({ apiKey: COMPOSIO_API_KEY });

  // Create Tool Router session for Google Maps
  const session = await composio.create(USER_ID, {
    toolkits: ['google_maps'],
  });
  const mcpUrl = session?.mcp.url;
What's happening:
  • The function checks for the required COMPOSIO_API_KEY environment variable
  • We're creating a Composio instance using our API key
  • The create method creates a Tool Router session for Google Maps
  • The returned url is the MCP server URL that your agent will use
7

Configure Claude Agent with MCP

const options: Options = {
  permissionMode: 'bypassPermissions',
  mcpServers: {
    composio: {
      type: 'http',
      url: mcpUrl,
      headers: { 'x-api-key': COMPOSIO_API_KEY }
    }
  },
  systemPrompt: 'You are a helpful assistant with access to Google Maps tools via Composio.',
  maxTurns: 10,
};
What's happening:
  • We're configuring the Claude Agent options with the MCP server URL
  • permissionMode: 'bypassPermissions' allows the agent to execute operations without asking for permission each time
  • The system prompt instructs the agent that it has access to Google Maps
  • maxTurns: 10 limits the conversation length to prevent excessive API usage
8

Create client and start chat loop

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    prompt: 'You: '
  });

  console.log('\nChat started. Type "exit" to quit.\n');

  let isProcessing = false;

  async function ask(prompt: string) {
    isProcessing = true;
    rl.pause();

    process.stdout.write('Claude is thinking...');
    const stream = query({ prompt, options });

    let firstChunk = true;
    for await (const msg of stream) {
      const content = (msg as any).message?.content || (msg as any).content;
      if (Array.isArray(content)) {
        for (const block of content) {
          if (block.type === 'text' && block.text) {
            if (firstChunk) {
              process.stdout.write('\r\x1b[K');
              process.stdout.write('Claude: ');
              firstChunk = false;
            }
            process.stdout.write(block.text);
          }
        }
      }
    }
    process.stdout.write('\n\n');

    isProcessing = false;
    rl.resume();
    rl.prompt();
  }

  rl.on('line', async (line) => {
    if (isProcessing) return;

    const input = line.trim();
    if (input === 'exit') {
      rl.close();
      process.exit(0);
    }
    if (input) await ask(input);
    else rl.prompt();
  });

  await ask('What can you help me with?');
}
What's happening:
  • The readline interface is created to handle user input and output
  • The query function is used to send the user's input to the agent
  • The chat loop continues until the user types 'exit' or 'quit'
9

Run the application

try {
  await chat();
} catch (error) {
  console.error(error);
  process.exit(1);
}
What's happening:
  • The chat function is the entry point for the application
  • The try-catch block is used to handle any errors that occur

Complete Code

Here's the complete code to get you started with Google Maps and Claude Agent SDK:

import 'dotenv/config';
import readline from 'node:readline';
import { Composio } from '@composio/core';
import { query, type Options } from "@anthropic-ai/claude-agent-sdk";

async function chat() {
  const { COMPOSIO_API_KEY, USER_ID } = process.env;
  if (!COMPOSIO_API_KEY || !USER_ID) {
    throw new Error('COMPOSIO_API_KEY and USER_ID required in .env');
  }

  const composio = new Composio({ apiKey: COMPOSIO_API_KEY });
  const session = await composio.create(USER_ID, {
    toolkits: ['google_maps']
  });
  const mcp_url = session?.mcp.url;

  const options: Options = {
    permissionMode: 'bypassPermissions',
    mcpServers: {
      composio: {
        type: 'http',
        url: mcp_url,
        headers: { 'x-api-key': COMPOSIO_API_KEY }
      }
    },
    systemPrompt: 'You are a helpful assistant with access to Google Maps tools via Composio.',
    maxTurns: 10,
  };

  const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    prompt: 'You: '
  });

  console.log('\nChat started. Type "exit" to quit.\n');

  let isProcessing = false;

  async function ask(prompt: string) {
    isProcessing = true;
    rl.pause();

    process.stdout.write('Claude is thinking...');
    const stream = query({ prompt, options });

    let firstChunk = true;
    for await (const msg of stream) {
      const content = (msg as any).message?.content || (msg as any).content;
      if (Array.isArray(content)) {
        for (const block of content) {
          if (block.type === 'text' && block.text) {
            if (firstChunk) {
              process.stdout.write('\r\x1b[K');
              process.stdout.write('Claude: ');
              firstChunk = false;
            }
            process.stdout.write(block.text);
          }
        }
      }
    }
    process.stdout.write('\n\n');

    isProcessing = false;
    rl.resume();
    rl.prompt();
  }

  rl.on('line', async (line) => {
    if (isProcessing) return;

    const input = line.trim();
    if (input === 'exit') {
      rl.close();
      process.exit(0);
    }
    if (input) await ask(input);
    else rl.prompt();
  });

  await ask('What can you help me with?');
}

try {
  await chat();
} catch (error) {
  console.error(error);
  process.exit(1);
}

Conclusion

You've successfully built a Claude Agent SDK agent that can interact with Google Maps through Composio's Tool Router.

Key features:

  • Native MCP support through Claude's agent framework
  • Streaming responses for real-time interaction
  • Permission bypass for smooth automated workflows
You can extend this by adding more toolkits, implementing custom business logic, or building a web interface around the agent.
TOOLS

Supported Tools

Every Google Maps action and event your agent gets out of the box.

Autocomplete Place Predictions

Returns place and query predictions for text input.

Compute Route Matrix

Calculates travel distance and duration matrices between multiple origins and destinations using the Routes API, with various travel modes and OAuth2 support; some connections limit requests to 100 origin-destination pairs.

Geocode Address With Query

Tool to map addresses to geographic coordinates with query parameter.

Geocode Destinations

Tool to perform destination lookup and return detailed destination information including primary place, containing places, sub-destinations, landmarks, entrances, and navigation points.

Reverse Geocode Location

Tool to convert geographic coordinates (latitude and longitude) to human-readable addresses using reverse geocoding.

Geocode Place by ID

Tool to perform geocode lookup using a place identifier to retrieve address and coordinates.

Geocoding API

Geocode an address into geographic coordinates, reverse geocode coordinates to find an address, or look up a place by its Place ID using Google’s Geocoding API v4beta.

Geolocate Device

Estimate a device's geographic location from cell tower and WiFi observations.

Get 2D Map Tile

Tool to retrieve a 2D map tile image at specified coordinates for building custom map visualizations.

Get 3D Tiles Root

Tool to retrieve the 3D Tiles tileset root configuration for photorealistic 3D map rendering.

Get Place Details

Retrieves details for a specific place by place ID or resource name.

Get Route

Calculates one or more routes between two specified locations.

Get Time Zone

Retrieves time zone information for a specific geographic location and timestamp.

Lookup Aerial Video

Tool to look up an aerial view video by address or video ID.

Embed Google Map

Generates a Google Maps Embed URL and HTML iframe code for place, view, directions, street view, or search mode using an API key, without making an API call.

Nearby search

Searches for places (e.

Get Place Photo

Retrieves high quality photographic content from the Google Maps Places database.

Render Aerial Video

Starts rendering an aerial view video for a US postal address.

Text Search

Searches for places on Google Maps using a textual query (e.

Create Tiles Session

Creates a session token for 2D map tiles or Street View imagery, reusable for subsequent tile requests within its validity window.

FRAMEWORKS

How to build Google Maps MCP Agent with another framework

Claude Code logo

Claude Code

Use Google Maps MCP with Claude Code

Cursor logo

Cursor

Use Google Maps MCP with Cursor

ChatGPT logo

ChatGPT

Use Google Maps MCP with ChatGPT

Claude Cowork logo

Claude Cowork

Use Google Maps MCP with Claude Cowork

Antigravity logo

Antigravity

Use Google Maps MCP with Antigravity

OpenAI Agents SDK logo

OpenAI Agents SDK

Use Google Maps MCP with OpenAI Agents SDK

Grok Bot logo

Grok Bot

Use Google Maps MCP with Grok Bot

Muse logo

Muse

Use Google Maps MCP with Muse

Codex logo

Codex

Use Google Maps MCP with Codex

Grok Build logo

Grok Build

Use Google Maps MCP with Grok Build

VS Code logo

VS Code

Use Google Maps MCP with VS Code

OpenCode logo

OpenCode

Use Google Maps MCP with OpenCode

OpenClaw logo

OpenClaw

Use Google Maps MCP with OpenClaw

Hermes logo

Hermes

Use Google Maps MCP with Hermes

Atomic Agent logo

Atomic Agent

Use Google Maps MCP with Atomic Agent

Pi logo

Pi

Use Google Maps MCP with Pi

DeepSeek Harness logo

DeepSeek Harness

Use Google Maps MCP with DeepSeek Harness

Google ADK logo

Google ADK

Use Google Maps MCP with Google ADK

LangChain logo

LangChain

Use Google Maps MCP with LangChain

Vercel AI SDK logo

Vercel AI SDK

Use Google Maps MCP with Vercel AI SDK

Mastra AI logo

Mastra AI

Use Google Maps MCP with Mastra AI

LlamaIndex logo

LlamaIndex

Use Google Maps MCP with LlamaIndex

CrewAI logo

CrewAI

Use Google Maps MCP with CrewAI

Pydantic AI logo

Pydantic AI

Use Google Maps MCP with Pydantic AI

AutoGen logo

AutoGen

Use Google Maps MCP with AutoGen

FAQ

Frequently asked questions

Start with Google Maps.It takes 30 seconds.

Managed auth, hosted MCP servers, and every Google Maps tool your agent needs.Free to start.

Start building