Tutorial : Getting Started with Google MCP Services
Welcome to the tutorial on Google MCP Services, a set of fully-managed remote MCP Servers that span across various Google and Google Cloud services.
Developers can now simply point their AI agents or standard MCP clients like Gemini CLI to a globally-consistent and enterprise-ready endpoint for Google and Google Cloud services.
In this tutorial, we will first get an overview of what these MCP Servers mean, the initial list of Google / Google Cloud services for which MCP Servers are available and finally how to get started with them.
We will keep expanding this tutorial to demonstrate different Agents that can integrate and start interacting with these services via natural language.
How did we get here?
The Model Context Protocol (MCP) does not need much introduction. It is an open standard that hasemerged as the industry-sanctioned solution to this “last mile” problem, standardizing the interface between AI models and external systems. It serves a critical need to ensure that the agentic systems are grounded in real world data.
Given its popularity, it was probably a matter of time, before we saw MCP support emerging for a wide range of Google APIs that have been driving numerous applications, over the years. The question was not just about slapping a MCP protocol in front of the Google APIs but rather step back a bit, see how it can integrate into the larger ecosystem of not just Google APIs but other services that could address key requirements like security, scale and more.
On December 10, 2025 — we saw the official announcement of Google’s fully managed MCP services for its core cloud products — BigQuery, Google Maps, Google Kubernetes Engine (GKE), and Google Compute Engine (GCE).
Announcing official MCP support for Google services | Google Cloud Blog
This is an important step forward. By exposing these complex, petabyte-scale services through the standardized MCP interface, Google has effectively commoditized the creation of “Agentic AI.” Developers no longer need to write brittle API wrappers, manage complex authentication flows, or manually define JSON schemas for function calling. Instead, they can connect to the specific MCP endpoint for the Google Service and get going.
You can understand the big picture via the diagram shown below:
The above diagram currently represents just the 4 services for which MCP Servers have been announced. It ofcourse does not show the tight integration that these servers have with cross cutting concerns for e.g. Security integration with Google Cloud IAM (Identity Access Management). Service Enablement in respective Google Cloud Projects, a Directory to help discover these services and more. The tutorial will attempt to cover these step by step, but you get the big picture.
Google’s Managed Remote Server Architecture
Before we jump into the various MCP Servers, lets talk a bit about the “remote” part of these MCP Servers. There have been various MCP Servers that have been authored and which integrate with Google / Google Cloud Services, but these end up running locally and/or need to be hosted. While effective for local development, this model is insufficient for enterprise cloud architecture. Running a subprocess requires the host machine to have the necessary runtimes (Node.js, Python) and network access to the target API.
Enter Managed Remote MCP Servers. These are fully hosted services running on Google’s infrastructure, accessible via public HTTP endpoints.
- Transport Mechanism: Unlike the local stdio transport or the persistent Server-Sent Events (SSE) used in some web implementations, Google’s services utilize Streamable HTTP. This allows for stateless, scalable interaction patterns compatible with standard load balancers and security proxies.
- Endpoint Uniformity: Each service is exposed via a predictable domain structure, such as bigquery.googleapis.com/mcp or mapstools.googleapis.com/mcp. This uniformity simplifies network configuration and firewall rules.
- Security Integration: Because these are managed Google Cloud services, they integrate natively with Identity and Access Management (IAM). Authentication is not handled by passing raw API keys in the prompt (a major security risk) but via OAuth 2.0 and Application Default Credentials (ADC), ensuring that the agent only has the permissions granted to its underlying service identity.
This architectural choice means that an enterprise developer does not need to deploy a container to host the BigQuery MCP server; it already exists. They simply need to configure their client to talk to the endpoint, radically lowering the barrier to entry for building sophisticated data agents.
Deep Dive into Supported Google Cloud Services
As mentioned earlier, Google has launched four primary managed MCP servers:
- BigQuery
- Google Maps
- Google Kubernetes Engine (GKE)
- Google Compute Engine (GCE)
Keep in mind that these MCP servers expose a set of tools. It is important that as a developer you understand the tools proided by each of the services in order to design effective agent workflows.
BigQuery MCP Server: The Analytical Engine
Endpoint: bigquery.googleapis.com/mcp
The BigQuery MCP server acts as the semantic bridge between natural language questions and SQL execution. It’s core intent is to abstracts the complexity of the BigQuery API into a set of tools that an LLM can invoke to explore data and derive insights.
You can find more information on the BigQuery MCP Server over here.
Use the BigQuery remote MCP server | Google Cloud Documentation
While the specific tool list is dynamically discoverable, the core functionality centers on data introspection and query execution.
How does this play out with Agents? This server allows for the creation of intelligent agents and a user can ask, “How did sales in the Northeast region compare to the Southwest last quarter?” The agent, using the BigQuery MCP server, can construct the SQL query, execute it against petabytes of data, and interpret the returned JSON result to formulate a natural language answer.
Google Maps Grounding Lite: Geospatial Intelligence
Endpoint: mapstools.googleapis.com/mcp
The “Maps Grounding Lite” server is a specialized wrapper around the Google Maps Platform, optimized specifically for LLM grounding. It is designed to prevent hallucinations related to physical locations and travel logistics.
You can check out more information Ground Lite over here.
Grounding Lite | Google Maps Platform | Google for Developers
Here are its key tools:
search_places: This is the entry point for geospatial discovery. It is not just a text search; it supports a sophisticated location_bias parameter.
compute_routes: This tool calculates travel logistics, requires origin and destination supports Travel modes: DRIVE and WALK and returns route distance and duration information
lookup_weather: A critical utility for context-aware agents since it provides current conditions, hourly forecasts and daily forecasts.
How does this play out with Agents? Allows agents to answer complex logistical questions like “Can I make a 5 PM meeting in Downtown if I leave the airport at 4 PM?” or to provide advice like “You should take an umbrella for your walk to the station”.
Google Kubernetes Engine (GKE) MCP Server: The DevOps Operator
Endpoint: container.googleapis.com/mcp
The GKE MCP server exposes key Kubernetes control plane primtives and is currently limited to read operations. You can view all the tools that are currently exposed by the GKE MCP Server here:
Tools Overview: container.googleapis.com | Google Kubernetes Engine (GKE) | Google Cloud Documentation
While the current documentation highlights read-heavy operations for safety, the architecture supports the full breadth of the GKE API.
Google Compute Engine (GCE) MCP Server: Infrastructure Management
Endpoint: compute.googleapis.com/mcp
The GCE server mirrors the GKE server but focuses on virtual machine primitives. You can view all the tools that are currently exposed by the GCE MCP Server over here.
Tools Overview: compute.googleapis.com | Compute Engine | Google Cloud Documentation
Building Intelligent Agents
Let’s get started now to build out Agents that utilize these services. As we mentioned earlier, these services are closely integrated with Google Cloud. As a result, before we get started, we need to do some initial setup that ensures that our Google Cloud Project is ready. By ready, it means ensuring that the following tasks are done:
- The right Google Cloud Services are enabled (BigQuery, GKE, Maps, etc)
- The MCP Servers are enabled
- IAM Permissions are setup (More on this in a moment)
We will be executing everything in Google Cloud Shell. Before you begin, please make sure of the following:
Project Setup and API Enablement
- In the Google Cloud Console, on the project selector page, select or create a Google Cloud project.
- Make sure that billing is enabled for your Cloud project.
- You’ll use Cloud Shell, a command-line environment running in Google Cloud that comes preloaded gcloud CLI and many other development tools. Click Activate Cloud Shell at the top of the Google Cloud console.
- Once connected to Cloud Shell, you check that you’re already authenticated and that the project is set to your project ID using the following command: gcloud auth list
- Run the following command in Cloud Shell to confirm that the gcloud command knows about your project: gcloud config list project
- If your project is not set, use the following command to set it:
gcloud config set project <YOUR_PROJECT_ID> - Enable the required APIs via the command shown below. This could take a few minutes, so please be patient.
gcloud services enable bigquery.googleapis.com \
compute.googleapis.com \
container.googleapis.com \
mapstools.googleapis.com
On successful execution of the command, you should see a message similar to the one shown below: Operation “operations/…” finished successfully.
Enable Google MCP Services
The MCP services are currently in a beta state and require explicit enablement via the gcloud beta commands. Do not skip this step.
Note: The commands below enable all the MCP Services that are currently available. You may choose to selectively enable only the ones that you are interested in.
# 1. Define your project variables
export PROJECT_ID=$(gcloud config get-value project)
export USER_EMAIL=$(gcloud config get-value account)
# 2. CRITICAL: Enable the MCP Endpoints explicitly
# These are distinct service interfaces from the product APIs
gcloud beta services mcp enable bigquery.googleapis.com --project=$PROJECT_ID
gcloud beta services mcp enable mapstools.googleapis.com --project=$PROJECT_ID
gcloud beta services mcp enable container.googleapis.com --project=$PROJECT_ID
gcloud beta services mcp enable compute.googleapis.com --project=$PROJECT_ID
Identity and Access Management (IAM)
The MCP servers enforce a dual-layer security model. An agent must pass two gates to execute a tool:
- Gate 1 (The MCP Gate): The identity must have the roles/mcp.toolUser role. This grants permission to talk to the MCP server itself.
- Gate 2 (The Service Gate): The identity must also have the underlying permission for the action (e.g., roles/bigquery.dataViewer to run a query).
Grant the MCP Tool User role to your identity. If asked for a condition, please select “No condition”.
gcloud projects add-iam-policy-binding $PROJECT_ID \
--member="user:$USER_EMAIL" \
--role="roles/mcp.toolUser"
API Key Generation (Maps Only)
The Maps Grounding Lite server is unique; while it uses IAM for access control, it also requires an API Key for quota tracking and billing assignment.
First up, create the key as shown below:
# Create the key
gcloud alpha services api-keys create --display-name="Maps-MCP-Key"
You should get an output that looks something like this:
Operation [operations/akmf.p7-415458962931-91c21f06-27ab-4efd-b06f-4360e5295221] complete. Result: {
"@type":"type.googleapis.com/google.api.apikeys.v2.Key",
"createTime":"2025-12-11T09:24:56.329498Z",
"displayName":"Maps-MCP-Key",
"etag":"W/\"+1zufzS9aY/ZdRj6r8XeCg==\"",
"keyString":"SOME_LARGE_UUID",
"name":"projects/.../keys/...",
"uid":"....",
"updateTime":"2025-12-11T09:24:56.448483Z"
}
Note down the value of keyString key in the above result object. You will need it later.
Integrate Google Maps MCP Server
Let’s first use Gemini CLI and setup the Google Maps MCP Server.
Note that Gemini CLI is available on Google Cloud Shell. We are going to first create a folder in Google Cloud Shell named gemini-cli-projects and then navigate into that folder i.e. cd gemini-cli-projects.
Now give the following command to add the Google Maps MCP Server. Remember to replace the YOUR_MAPS_API_KEY with the key values that we created earlier.
gemini mcp add -s user -t http -H 'X-Goog-Api-Key: YOUR_MAPS_API_KEY' maps-grounding-lite-mcp https://mapstools.googleapis.com/mcp
This will add the Maps MCP Server to the Gemini CLI settings.json file and on successful execution of the above command, it will display a message similar to the one shown below:
MCP server "maps-grounding-lite-mcp" added to user settings. (http)
Launch Gemini CLI and then invoke the /mcp list command. This will list the Maps MCP Server and the available tools.
🟢 maps-grounding-lite-mcp - Ready (3 tools)
Tools:
- compute_routes
- lookup_weather
- search_places
You can now give your prompts that could result in Gemini CLI picking up the specific tools from the Maps MCP Server.
I tried the following prompt:
What are some economical breakfast places in South Mumbai?
This resulted in the correct tool being picked up, as given below:
We got the following response:
✦ Here are some economical breakfast places in South Mumbai:
* Ayyappa Breakfast Station is a breakfast restaurant located at Shop No 5, Bawla Masjid, N M Joshi Marg, Delisle Rd, BDD Chawl, Lower Parel, Mumbai, Maharashtra
400013, India. It has a rating of 4.6 stars based on 65 reviews. They are open from 4:30 AM to 3:30 AM daily and have a price range of INR 1 to 200.
* Kuckeliku Breakfast House is a breakfast restaurant located at First Floor, Kamal Mansion, 4/25, Arthur Bunder Rd, near Radio Club, Apollo Bandar, Colaba, Mumbai,
Maharashtra 400005, India. It has a rating of 4.1 stars based on 645 reviews. They are open from 8:00 AM to 7:00 PM, with Tuesdays closed.
* Bake House Cafe is a cafe located at Chamber of Commerce Ln, Kala Ghoda, Fort, Mumbai, Maharashtra 400001, India. It has a rating of 4.4 stars based on 3520 reviews.
They serve breakfast, lunch, and dinner and are open from 8:00 AM to 1:00 AM daily.
* Kala Ghoda Cafe is a cafe located at 10, Rope Walk Ln, Kala Ghoda, Fort, Mumbai, Maharashtra 400001, India. It has a rating of 4.3 stars based on 5384 reviews. They
serve breakfast, lunch, and dinner and are open from 8:00 AM to 12:00 AM daily.
* The Nutcracker is a cafe located at Dr, Forbes St, Lion Gate, Fort, Mumbai, Maharashtra 400001, India. It has a rating of 4.4 stars based on 3171 reviews. They serve
breakfast, lunch, and dinner and are open from 8:00 AM to 11:45 PM, with Mondays opening at 12:00 PM.
Try it out with your own queries. Try invoking the other tools by asking about the weather or a route?
This is what happened when I gave the following prompt:
I am planning a drive from Mumbai to Pune tomorrow. What should I expect?
It gave the following response. You can see that it is going to lookup weather and then compute the route too. Nice !
I will check the weather forecast for tomorrow in Mumbai and Pune, and look up the driving route between the two cities.
╭────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────────╮
│ ? lookup_weather (maps-grounding-lite-mcp MCP Server) {"location":{"address":"Mumbai, India"},"date":{"year":2025,"day":12,"month":12}} ← │
│ │
│ MCP Server: maps-grounding-lite-mcp │
│ Tool: lookup_weather │
│ │
│ Allow execution of MCP tool "lookup_weather" from server "maps-grounding-lite-mcp"? │
│ │
│ ● 1. Yes, allow once │
│ 2. Yes, always allow tool "lookup_weather" from server "maps-grounding-lite-mcp" │
│ 3. Yes, always allow all tools from server "maps-grounding-lite-mcp" │
│ 4. No, suggest changes (esc) │
│ │
│ │
│ ⊷ lookup_weather (maps-grounding-lite-mcp MCP Server) {"date":{"day":12,"month":12,"year":2025},"location":{"address":"Pune, India"}} │
│ │
│ │
│ ⊷ compute_routes (maps-grounding-lite-mcp MCP Server) {"destination":{"address":"Pune, India"},"origin":{"address":"Mumbai, India"},"travelMode":"DRIVE"}
The final response is wonderful.
✦ Here is what you can expect for your drive from Mumbai to Pune tomorrow, Friday, December 12, 2025:
🚗 The Drive
* Distance: Approximately 154 km.
* Duration: Expect the drive to take around 3 hours, depending on traffic.
☀️ The Weather
It looks like a great day for a drive with clear, sunny skies in both cities and no rain forecast. However, there is a significant temperature difference to prepare
for:
* Mumbai: Warm and pleasant.
* High: ~30°C
* Low: ~23°C
* Pune: Sunny but much cooler, especially in the morning and evening.
* High: ~28°C
* Low: ~11°C
Recommendation: While you'll be comfortable in Mumbai, you might want to bring a light jacket or sweater for your time in Pune, as 11°C can feel quite chilly if you are
used to Mumbai's humidity. Safe travels
Integrate BigQuery MCP Server
Let’s configure the BigQuery MCP Server now in Gemini CLI.
Before we do that, you need to ensure that as the user executing the tools, you have the required permissions assigned to your account. Remember that we had already assigned the roles/mcp.toolUser that allowed you to make the MCP tool calls. For BigQuery, you need to ensure that your account also have the following roles:
- Run BigQuery jobs: BigQuery Job User (roles/bigquery.jobUser)
- Query BigQuery data: BigQuery Data Viewer (roles/bigquery.dataViewer)
Once that’s done, let’s proceed to setting up the BigQuery MCP Server.
Just like how we setup the Maps MCP Server in Gemini CLI in the previous section, we are going to configure the BigQuery MCP Server via a Gemini CLI extension.
To do that, create a file in the following path ~/.gemini/extensions/EXT_NAME/gemini-extension.json
We are going to name our extension as bqmcp , so put that in the EXT_NAME path above.
In summary, the content of ~/.gemini/extensions/bqmcp/gemini-extension.json will be:
{
"name": "bqmcp",
"version": "1.0.0",
"mcpServers": {
"bigquery-mcp-server": {
"httpUrl": "https://bigquery.googleapis.com/mcp",
"authProviderType": "google_credentials",
"oauth": {
"scopes": ["https://www.googleapis.com/auth/bigquery"]
},
"timeout": 30000,
"headers": {
"x-goog-user-project": "YOUR_PROJECT_ID"
}
}
}
}
Note that you should replace the YOUR_PROJECT_ID with your Google Cloud Project Id.
Restart Gemini CLI and then give the following command:
/extensions list
You should see that the extension has been setup successfully:
Give the following command to see the tools:
/mcp list
This will show the tools that are currently available from the BigQuery MCP Server:
🟢 bigquery-mcp-server (from bqmcp) - Ready (5 tools)
Tools:
- execute_sql
- get_dataset_info
- get_table_info
- list_dataset_ids
- list_table_ids
We can now give prompts like:
What are the datasets in GOOGLE_CLOUD_PROJECT_ID
For my project id, I see the following output:
✦ Here are the datasets in GOOGLE_CLOUD_PROJECT_ID:
* adk_logs (Location: US)
* bqml_tutorial (Location: US)
* cymbal_sales (Friendly Name: Cymbal Superstore Product Sales, Location: US)
* google_trends (Location: US)
* mbl_export (Location: US)
* mcp_bakery (Location: US)
* nyc_citibike_stations (Location: US)
I can now execute a query in a public dataset (Google Cloud Release Notes) as follows:
Find the release notes from `bigquery-public-data`.`google_cloud_release_notes`.`release_notes` for the last 2 days and group them by product
This produces the following(truncated the output):
✦ Here are the release notes from bigquery-public-data.google_cloud_release_notes.release_notes for the last 2 days, grouped by product:
---
Product: AI Hypercomputer
* Date: 2025-12-09, Type: FEATURE
Description:
Generally available: You can enable node health prediction in an AI-optimized GKE cluster to help the cluster avoid scheduling workloads on nodes that are likely to degrade within the next five hours. This
approach helps minimize interruptions for critical and interruption-sensitive workloads, such as large-scale training. For more information, see Enable node health prediction in a GKE cluster.
---
Product: Apigee API hub
* Date: 2025-12-09, Type: FEATURE
Description:
New add-on management page in API hub
A new Add-on Management page is now available in API hub. This page serves as a centralized location to enable, configure, and manage all your add-on services.
For more information, see Manage add-ons.
* Date: 2025-12-09, Type: NON_BREAKING_CHANGE
Description:
Actions tab changes
The Actions tab previously located in the API hub > Settings page is now removed, accounting for the following UI changes:
* You can now find and configure add-on services like Specification Linter and Semantic Search under the new unified Add-on Management page, alongside other API hub add-ons.
* The deprovisioning function is now moved to a dedicated top-level tab called Deprovision.
---
Product: Capacity Planner
* Date: 2025-12-09, Type: NON_BREAKING_CHANGE
Description:
The Google Cloud console has been changed as follows:
* An Overview page for Capacity Planner has been added. You can use the Overview page to view data that summarizes the overall resource usage for a project, folder, or organization, including potential
action items and the regional distribution of your resources.
* The data for the region distribution of your resources has been relocated: the doughnut charts have been replaced with a bar chart on the Overview page for Capacity Planner.
For more information, see View usage and forecast data.
---
Product: Cloud Interconnect
* Date: 2025-12-09, Type: FEATURE
Description:
Partner Cross-Cloud Interconnect for Amazon Web Services (AWS) is available in Preview.
Partner Cross-Cloud Interconnect for AWS provides an on-demand and reliable method for establishing cross-cloud transport, without having to manually set up networking components.
This connectivity is represented as region-to-region transport with an SLA-protected, coordinated underlay built with AWS that can be set up on-demand, and sized up and down based on your needs.
For more information, see Partner Cross-Cloud Interconnect for AWS overview. For available locations see Choose a paired location.
---
Product: Dataform
* Date: 2025-12-09, Type: FEATURE
Description:
Dataform offers enhanced IAM permissions, providing more granular control over resource creation and scheduling. Administrators can also enable private workspaces to restrict access to the workspace creator.
These features are in preview.
---
Product: Google Cloud Contact Center as a Service
* Date: 2025-12-09, Type: SERVICE_ANNOUNCEMENT
Description:
Mobile SDK version 2.15.1 patch
The Mobile SDK version 2.15.1 patch adds the following updates to the Android SDK:
* Android 16 compatibility: Mobile SDK 2.15.1 is compatible with Android 16.
* Edge-to-edge screen support: Mobile SDK 2.15.1 supports edge-to-edge.
* No predictive back system animations: Mobile SDK 2.15.1 doesn't support predictive back system animations. We expect to support this Android 16 capability in a future release.
---
Product: Google Kubernetes Engine
* Date: 2025-12-09, Type: FEATURE
Description:
In GKE version 1.34.1-gke.2541000 and later, you can specify secure tags for firewalls in the spec.nodePoolConfig.resourceManagerTags field in ComputeClasses. GKE adds those secure tags to the nodes that GKE
creates for that ComputeClass, so that you can target nodes by using these tags in firewall policies. For more information, see Selectively enforce firewall policies in GKE.
---
Product: Google SecOps
* Date: 2025-12-09, Type: FEATURE
Description:
Create new reference lists
You can still create new reference lists.
This feature nullifies certain content in the release note from August 19, 2025, which specified that from October 2025, you would no longer be able to create new reference lists.
Note: Because the reference list functionality is being phased out of the Google SecOps platform (see "Reference lists" in Feature deprecations), we recommend that you use data tables to provide expanded
functionality, instead of reference lists.
For more information on the BigQuery Maps Server, tools, sample prompts, check out the documentation:
Use the BigQuery remote MCP server | Google Cloud Documentation
This tutorial does not cover the GKE and GCE MCP Server and interested readers can visit the documentation listed at the start to configure them in similar fashion.
So far, we enabled the MCP Servers in our Google Cloud Project and then tested them out in an available AI Agent i.e. Gemini CLI. We shall now proceed to understanding how we can write an Agent using the Agent Development Kit and which will interface to the same MCP Servers that we have setup.
This section (coming up next) is completely optional if you do not plan to develop an Agent and instead are fine with simply configuring the Google MCP Servers in familiar AI Apps like Gemini CLI, Claude, etc.
Developing an Agent using Agent Development Kit
We will be using the Google Agent Development Kit (ADK) to develop a sample agent in Python that interacts with the Google Maps MCP Server. This sample will suffice to demonstrate how you can integrate these MCP Servers via the StreamableHTTP class in the Agent Development Kit.
To follow along, you will need to be familiar with the Python language, creating environments and read along code that develops agents using the Agent Development Kit.
Assuming that you are still in Google Cloud Shell terminal session, create a folder inside your home directory, named mcp-server-agent and navigate to this lab using cd mcp-server-agent command.
Let’s create the Python environment first and install the dependencies.
Open a new terminal tab in Cloud Shell and create a folder named my-agents as follows. Navigate to the my-agents folder too.
mkdir my-agents
cd my-agents
Now, let’s create a virtual Python environment using venv as follows:
python -m venv .venv
Activate the virtual environment as follows:
source .venv/bin/activate
Install the ADK package.
pip install google-adk
We are now going to use adk to create a scaffolding for our sample Maps Agent via the adk create command with an app name (maps_agent)as given below.
adk create maps_agent
Follow the steps and select the following:
- Gemini model for choosing a model for the root agent : gemini-2.5-flash
- Choose Vertex AI for the backend.
- Your default Google Project Id and region will be displayed. Select the default itself.
This should display the following output:
Agent created in <YOUR_HOME_FOLDER>/my-agents/maps_agent:
- .env
- __init__.py
- agent.py
Observe the folder in which a default template (agent.py) and required files for the Agent have been created. You can see the files via the ls -al command in the terminal in the <YOUR_HOME_FOLDER>/my-agents/maps_agent directory.
First up is the .env file. This file is already created as mentioned earlier and you can just view the contents of the file that are shown below:
GOOGLE_GENAI_USE_VERTEXAI=1
GOOGLE_CLOUD_PROJECT=YOUR_GOOGLE_PROJECT_ID
GOOGLE_CLOUD_LOCATION=YOUR_GOOGLE_PROJECT_REGION
The values indicate that we will be using Gemini via Vertex AI along with the respective values for the Google Cloud Project Id and location.
Add the following value to it and replace YOUR_GOOGLE_MAPS_KEY with the Google Maps API Key that we generated in an earlier section.
MAPS_API_KEY=YOUR_GOOGLE_MAPS_KEY
Now, replace the agent.py code with the following:
import os
import logging
from dotenv import load_dotenv
from google.adk.agents import LlmAgent
from google.adk.tools.mcp_tool import McpToolset
from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams
# Setup logging to see the tool calls in action
logging.basicConfig(level=logging.INFO)
load_dotenv()
# Configuration Constants
MAPS_MCP_URL = "https://mapstools.googleapis.com/mcp"
# Ensure you exported this in your shell or.env file
MAPS_API_KEY = os.getenv("MAPS_API_KEY")
if not MAPS_API_KEY:
raise ValueError("MAPS_API_KEY not found. Please set it in your environment.")
# Initialize the Toolset
# We use StreamableHTTPConnectionParams for remote Google servers.
# The 'X-Goog-Api-Key' header is mandatory for the Maps MCP server.
maps_toolset = McpToolset(
connection_params=StreamableHTTPConnectionParams(
url=MAPS_MCP_URL,
headers={
"X-Goog-Api-Key": MAPS_API_KEY
}
)
)
# Define the Agent
root_agent = LlmAgent(
model="gemini-3-pro-preview",
name="root_agent",
instruction="""
You are an expert Travel Planner assistant.
Your goal is to help users plan trips by finding locations and checking logistics.
Guidelines:
1. Use 'search_places' to find the precise coordinates of locations mentioned by the user.
If the location is ambiguous (e.g. "Springfield"), ask for clarification.
2. Use 'compute_routes' to calculate drive times between these locations.
3. Use 'lookup_weather' to check the forecast for the destination.
Always summarize the travel plan with estimated times and weather warnings.
""",
tools=[maps_toolset]
)
Test the Agent App locally
From the existing terminal window and give the following command. Ensure that you are in the parent folder (my-agents) containing the maps-agent folder.
adk web
A sample execution is shown below:
INFO: Started server process [2691]
INFO: Waiting for application startup.
+-----------------------------------------------------------------------------+
| ADK Web Server started |
| |
| For local testing, access at http://127.0.0.1:8000. |
+-----------------------------------------------------------------------------+
INFO: Application startup complete.
INFO: Uvicorn running on http://127.0.0.1:8000 (Press CTRL+C to quit)
Click on the last link and it should bring up a web console to test out the Agent.
You should see the following launched in the browser as shown below:
You can now provide your prompts. A sample run is shown below:
I give it a query as follows:
This concludes how you can integrate the MCP Server as a Tool in your agent written using the Agent Development Kit (ADK).
Deep Dive Codelab
For a more advanced version of an Agent, written in Agent Development Kit, that integrates both the Maps MCP Server and BigQuery MCP Server, check out this deep dive codelab written by Rachael Deacon-smith and Jeff Nelson, that helps you solve business problems about a fictitious bakery dataset.
Build a Location Intelligence ADK Agent with MCP servers for BigQuery and Google Maps | Google Codelabs
1-page Infographic
Here is a 1-page infographic created by NotebookLM for the content in this tutorial. Take a look.
Conclusion
The release of Google’s managed MCP services marks an interesting moment for developers working with Google services. Using the MCP Servers would go a long way to remove a big friction point in agent development, for agents integrating with various Google Services.
For the enterprise developer, the path is now clear:
- Enable the Endpoints: Activate the MCP interfaces for BigQuery, Maps, GKE, and GCE.
- Configure Identity: Use IAM roles (mcp.toolUser) rather than scattered API keys to secure access.
- Adopt the ADK or Gemini CLI: Leverage these frameworks to orchestrate workflows that span data, location, and infrastructure.
With Managed MCP Servers, we have entered the era of the secure, governed, and highly capable AI Agent.
Let me know what you build in the comments. Happy to learn.
Google Cloud Platform Technology Updates
Tired of sifting through Google Cloud updates? My bi-weekly newsletter delivers key Google Cloud Platform news and announcements you need to know, to your inbox. Subscribe now.
Tutorial : Getting Started with Google MCP Services was originally published in Google Cloud – Community on Medium, where people are continuing the conversation by highlighting and responding to this story.
Source Credit: https://medium.com/google-cloud/tutorial-getting-started-with-google-mcp-services-60b23b22a0e7?source=rss—-e52cf94d98af—4
About the Author
