Integrate Google's Vertex AI Agent with Live Amazon Athena Data via CData Connect AI

Vertex AI provides a development ecosystem for building AI agents using the Agent Development Kit (ADK). ADK enables developers to create tool-augmented agents that can reason, take actions, and interact with external systems through structured tool interfaces. These agents can be tested locally in the ADK Web interface and extended with advanced logic for enterprise workflows.

By integrating Vertex AI ADK with CData Connect AI through the built-in MCP (Model Context Protocol) Server, your agents gain the ability to query, analyze, and act on live Amazon Athena data in real time. This connection bridges Google's agent-building framework with the governed enterprise connectivity of CData Connect AI, ensuring every request runs securely against authorized data sources without manual data movement.

This article outlines the steps to configure Amazon Athena connectivity in Connect AI, generate the required authentication token, configure the Vertex AI ADK environment, and verify that your agent can successfully communicate with live Amazon Athena data through Connect AI.

Getting Started

---

Step 1: Configure Amazon Athena connectivity for Vertex AI

Connectivity to Amazon Athena from Vertex AI is made possible through CData Connect AI's Remote MCP Server. To interact with Amazon Athena data from Vertex AI, start by creating and configuring a Amazon Athena connection in CData Connect AI.

1. Log into Connect AI, click Sources, and then click Add Connection
👁 Adding a connection in Connect AI

2. Select Amazon Athena from the Add Connection panel
👁 Selecting data source

3. Enter the necessary authentication properties to connect to Amazon Athena.

   Authenticating to Amazon Athena

   To authorize Amazon Athena requests, provide the credentials for an administrator account or for an IAM user with custom permissions: Set to the access key Id. Set to the secret access key.

   Note: Though you can connect as the AWS account administrator, it is recommended to use IAM user credentials to access AWS services.

   Obtaining the Access Key

   To obtain the credentials for an IAM user, follow the steps below:

   1. Sign into the IAM console.
   2. In the navigation pane, select Users.
   3. To create or manage the access keys for a user, select the user and then select the Security Credentials tab.

   To obtain the credentials for your AWS root account, follow the steps below:

   1. Sign into the AWS Management console with the credentials for your root account.
   2. Select your account name or number and select My Security Credentials in the menu that is displayed.
   3. Click Continue to Security Credentials and expand the Access Keys section to manage or create root account access keys.

   Authenticating from an EC2 Instance

   If you are using the CData Data Provider for Amazon Athena 2018 from an EC2 Instance and have an IAM Role assigned to the instance, you can use the IAM Role to authenticate. To do so, set to true and leave and empty. The CData Data Provider for Amazon Athena 2018 will automatically obtain your IAM Role credentials and authenticate with them.

   Authenticating as an AWS Role

   In many situations it may be preferable to use an IAM role for authentication instead of the direct security credentials of an AWS root user. An AWS role may be used instead by specifying the . This will cause the CData Data Provider for Amazon Athena 2018 to attempt to retrieve credentials for the specified role. If you are connecting to AWS (instead of already being connected such as on an EC2 instance), you must additionally specify the and of an IAM user to assume the role for. Roles may not be used when specifying the and of an AWS root user.

   Authenticating with MFA

   For users and roles that require Multi-factor Authentication, specify the and connection properties. This will cause the CData Data Provider for Amazon Athena 2018 to submit the MFA credentials in a request to retrieve temporary authentication credentials. Note that the duration of the temporary credentials may be controlled via the (default 3600 seconds).

   Connecting to Amazon Athena

   In addition to the and properties, specify , and . Set to the region where your Amazon Athena data is hosted. Set to a folder in S3 where you would like to store the results of queries.

   If is not set in the connection, the data provider connects to the default database set in Amazon Athena.

   👁 Configuring a connection (Salesforce is shown)
   
4. Click Save & Test
5. Navigate to the Permissions tab and update user-based permissions
👁 Updating permissions

Add a Personal Access Token

A Personal Access Token (PAT) is used to authenticate the connection to Connect AI from Vertex AI. It is best practice to create a separate PAT for each integration to maintain granular access control.

1. Click the gear icon () at the top right of the Connect AI app to open Settings
2. On the Settings page, go to the Access Tokens section and click Create PAT
3. Give the PAT a descriptive name and click Create
👁 Creating a new PAT

4. Copy the token when displayed and store it securely. It will not be shown again

With the Amazon Athena connection configured and a PAT generated, Vertex AI can now connect to Amazon Athena data through Connect AI.

Step 2: Install required dependencies

Enable the necessary Google Cloud APIs so Vertex AI ADK can run Gemini models, build agent environments, and access supporting services inside your Google Cloud project. These APIs provide the backend capabilities that ADK relies on during development and execution.

1. Visit the Google Cloud Console
2. Click the Project Picker at the top of the page and choose New Project
👁 Creating a new Google Cloud project

3. Create the project and note the Project ID. Save this ID later for environment configuration
4. From the left navigation menu, open APIs & Services and then choose Enabled APIs & Services
5. Click Enable Apis and services
👁 Enabling new APIs

6. Enable the following APIs:
   • Vertex AI API
   • Cloud Build API
   • Artifact Registry API
   • Service Networking API
   • Cloud Logging API

With these services enabled, your Google Cloud project is prepared for Vertex AI ADK development and local tool execution.

Prepare the Vertex AI ADK project folder

Create the project directory and set up the Python environment. This step prepares a clean workspace where ADK installs correctly and loads your agent without dependency conflicts.

1. Open Google Cloud console and select the Cloud Shell. Make sure to select the project you created from the project picker.
👁 Selecting Google Cloud Shell

2. Create the ADK project directories:

				mkdir -p ~/adk_agents/cdata_mcp_agent
				cd ~/adk_agents/cdata_mcp_agent 
			

3. Create and activate a Python virtual environment:

		python3 -m venv .venv
		source .venv/bin/activate
	

4. Install the required ADK and MCP packages:

				python -m pip install --upgrade pip
				python -m pip install google-adk
				python -m pip install mcp
				python -m pip install --upgrade "google-cloud-aiplatform[agent_engines]"
			

Step 3: Create the ADK Agent files

Define the agent modules so ADK recognizes your agent. This structure allows Vertex AI to load your MCP configuration and register the tools exposed by Connect AI.

1. Create agent.py file and paste the code below in it

		
import os
import base64
import logging
 
from google.adk.agents import LlmAgent
from google.adk.tools.mcp_tool.mcp_toolset import MCPToolset
from google.adk.tools.mcp_tool.mcp_session_manager import StreamableHTTPConnectionParams
 
# ---------- Logging ----------
logging.basicConfig(level=logging.INFO)
logger = logging.getLogger(__name__)
 
# ---------- CData MCP config ----------
CDATA_MCP_URL = os.environ.get("CDATA_MCP_URL", "https://mcp.cloud.cdata.com/mcp")
CDATA_USER_ID = os.environ.get("CDATA_USER_ID")
CDATA_PAT = os.environ.get("CDATA_PAT")
 
tools = []
 
if not (CDATA_USER_ID and CDATA_PAT):
 logger.warning(
 "CData MCP credentials not set (CDATA_USER_ID or CDATA_PAT missing); "
 "starting agent WITHOUT MCP tools."
 )
else:
 # Basic auth header: base64("user:pat")
 basic_auth_bytes = f"{CDATA_USER_ID}:{CDATA_PAT}".encode("utf-8")
 basic_auth_header = base64.b64encode(basic_auth_bytes).decode("utf-8")
 
 try:
 logger.info("Initializing CData MCPToolset against %s", CDATA_MCP_URL)
 
 tools.append(
 MCPToolset(
 connection_params=StreamableHTTPConnectionParams(
 url=CDATA_MCP_URL,
 headers={
 "Authorization": f"Basic {basic_auth_header}",
 # ADK handles content-type etc. internally;
 # we just pass auth headers.
 },
 ),
 )
 )
 
 logger.info("CData MCPToolset initialized successfully.")
 except Exception as e:
 logger.exception("Failed to initialize CData MCPToolset")
 
# ---------- Root agent ----------
root_agent = LlmAgent(
 model="gemini-2.0-flash",
 name="cdata_mcp_agent",
 instruction=(
 "You are a data assistant. Use the CData MCP tools (if available) to "
 "list connections, list catalogs/schemas/tables, and run SQL-style queries."
 ),
 tools=tools,
)
	

2. Create another file __int__.py and paste the code below in it

		
		from .agent import root_agent
		__all__ = ["root_agent"]

Export environment variables

Export the required environment variables to authenticate to Connect AI. These values enable the agent to initialize the MCP toolset and communicate with Connect AI. Before you do that obtain a Google API key so ADK can authenticate to Gemini models. This key enables the agent to run LLM reasoning and route tool calls correctly inside the Vertex AI ADK environment.

1. Visit the Google AI Studio API Key page
2. Click Create API Key. Provide a name for the api-key and choose or create a project if you do not have one
👁 Creating a Gemini API Key

3. Click on Create a key and then copy the API key
4. Return to the Google Cloud Shell page and run the environment variable exports. Replace "your_cdata_email", "your_pat", "your-project-id", and "your_google_api_key" with your values

		export CDATA_MCP_URL="https://mcp.cloud.cdata.com/mcp"
		export CDATA_USER_ID="your_cdata_email"
		export CDATA_PAT="your_pat"
		export GOOGLE_API_KEY="your_google_api_key"
		export VERTEXAI_PROJECT="your-project-id"
		export VERTEXAI_LOCATION="us-central1"
	

Step 4: Launch the ADK web interface

Start the ADK Web interface to load your agent. The interface initializes the runtime and makes your MCP-enabled agent available for interactive testing.

1. Move to the parent folder:

				cd ~/adk_agents
			

2. Launch ADK Web:

				adk web .
			

👁 Launching ADK Web

Step 5: Select your agent and test MCP connectivity

Select your agent from the ADK Web interface. ADK loads the MCP tools and prepares the environment so you issue live MCP queries.

1. Open the ADK Web UI from the browser tab
2. Select cdata_mcp_agent from the agent dropdown
👁 Selecting the ADK agent in the UI

3. Enter list catalogs in the chat panel. ADK returns a live list of your Connect AI connections
👁 Listing connections through Connect AI

At this point, your Vertex AI ADK agent communicates with the CData Connect AI MCP Server and retrieves live Amazon Athena data metadata through remote MCP tools.

Get CData Connect AI

To access hundreds of SaaS, Big Data, and NoSQL sources directly from your cloud applications, try CData Connect AI today!