Source: Generated by Imagen3 on Vertex AI
Google just dropped their new open-source Agent Development Kit (ADK) for building multi-agent AI applications. It’s got many interesting features but there is one I just discovered and it is definitely worth sharing: it connects directly with GCP Integration Connectors. This basically gives your AI agents ‘tools’ to not just grab info, but actually do things in over 100 different Google and third-party systems securely. Yeah, they can perform actions, not just read data! All you need to do is set up the connection.
Okay, let’s see how this works with a quick example. To start, I created a new ‘Connection’ in GCP, setting its location to Warsaw (europe-central2), which just means Google will run the connector’s infrastructure in that region.
Plus, you get built-in logging to see what the connector is up to. You can choose how much detail you want — standard Info, detailed Debug, or just catching Errors — which is pretty useful for keeping tabs on things.
Now, because these connectors often link up to important business systems, authentication is obviously key. Integration Connectors are built for this (‘enterprise-grade’), supporting secure methods like OAuth2 (though the details of OAuth2 are a bigger topic for another time). I used OAuth2 - Authorization code (Google Managed) — option.
There’s one specific setting here that’s really worth highlighting: Enable Authentication Override. t plays a key role in how the connection handles user permissions, as we’ll touch on next.
We won’t dive too deep into Enable Authentication Override right now, but the main point is it allows the connector to perform actions using the permissions of the actual end-user talking to the agent. So, for this Google Drive connection to work like that, we first need to explicitly authorize it to access our GDrive, which pops up a consent screen like this:
Boom! Just like that, we’ve got a working connector ready to talk to Google Drive.
Alright, so we have our connector ready. Now, how do we let our agent built with the Agent Development Kit actually use it? We do this by wrapping the connector as a ‘Tool’ using ADK’s ApplicationIntegrationToolset. You basically tell it which connection to use, give this new tool a name, and provide an ‘instruction’ – a hint for the agent on when it should consider using this tool. You can also specify exactly which operations or actions the tool is allowed to perform (using entity_operations or actions). For this little demo, I just want it to be able to list files on my GDrive (actions = [“Get_files”], so the setup looks like this:
from google.adk.tools.application_integration_tool.application_integration_toolset import ApplicationIntegrationToolset
connector_tool = ApplicationIntegrationToolset(
project="genai-app-builder", # TODO: replace with GCP project of the connection
location="europe-central2", #TODO: replace with location of the connection
connection="gdrive-connection", #TODO: replace with connection name "projects/genai-app-builder/locations/europe-central2/connections/gdrive-connection", ##
entity_operations={},##{"Entity_One": ["LIST","CREATE"], "Entity_Two": []},#empty list for actions means all operations on the entity are supported.
actions=["GET_files], #TODO: replace with actions
##service_account_credentials='{...}', # optional
tool_name="tool_list_gdrive_files",
tool_instructions="Use this tool to list gdrive files"
)
How do I know which actions are supported by given connector? Documentation states to use API to get connector characteristics. I create new Application Integration and added only Connection object. When configuring connection I have a long list of actions supported by this connector:
Then connection description includes string name of the selected action endpoint.
Right, our connector_tool for GDrive is all set. Now we just need to define the actual agent and make sure it knows it can use this tool for any Google Drive related tasks.
basic_agent = Agent(
model=MODEL,
name=AGENT_APP_NAME,
description="You are helpful assitant",
instruction="If they ask you how you were created, tell them you were created with the Google Agent Framework.",
generate_content_config=types.GenerateContentConfig(temperature=0.2),
tools = connector_tool.get_tools(),
)
Okay, agent defined! Before we can actually ask it to do anything (like listing those GDrive files), we need to start a ‘session’ for our conversation:
_session_id="session6"
session = session_service.create_session(app_name=AGENT_APP_NAME, user_id='user', session_id=_session_id)
Session’s ready. Now we need the ‘runner’:
runner = Runner(app_name=AGENT_APP_NAME, agent=basic_agent, artifact_service=artifact_service, session_service=session_service)
As the agent figures things out and uses tools, the ADK framework sends out status updates called ‘events’. We’ll use a small helper function to listen to these events, specifically watching for the one marked as the ‘final response’, because that contains the actual message we want to display to the user:
def get_response(runner, session, message):
content = types.Content(role='user', parts=[types.Part(text=message)])
events = runner.run(user_id=session.user_id, session_id=session.id, new_message=content)
final_response = None
for _, event in enumerate(events):
print(event)
is_final_response = event.is_final_response()
if is_final_response:
final_response = event.content.parts[0].text
return final_response
Okay, moment of truth! Let’s feed our question, “list files on my gdrive”, to the runner and use our helper function to catch the agent’s response:
resp = get_response(runner, session, "list files on my gdrive")
resp
And here’s what the agent came back with
I found the following files on your Google Drive:
- Screenshot 2025-04-07 at 18.04.20.png (image/png)
- bq-results-20230213-140942-1676297518306 (application/vnd.google-apps.folder)
- bq-results-20230213-140942-1676297518306.csv (text/csv)
And yup, taking a peek at my Google Drive confirms that’s exactly what’s in there right now:
Now, hold on a sec — there’s one crucial bit of setup you need to do first to make this magic happen. It’s a one-time thing, but it’s key. You need to create a specific workflow using the ‘Application Integration’ service in GCP (even if you don’t plan on building complex integrations yourself). Think of it as enabling the ‘connector-as-a-tool’ feature. You just need to create one integration flow from a special template Google provides, called ‘Connection Tool’. This template acts as a universal wrapper that gets triggered whenever your agent decides to use any of the Integration Connectors you’ve set up as tools.
Finding it is simple: Go to the ‘Application Integration’ service in your Google Cloud console, click the ‘Templates’ option, and then filter or search for ‘tool’. You should see the ‘Connection Tool’ template pop up — click on that!
Okay, once you’ve selected the ‘Connection Tool’ template, just click the [Use Template] button to kick off the creation process.
Okay, two crucial things here:
- Name it correctly: You absolutely need to name this integration ExecuteConnection. Make sure it’s spelled exactly that way.
- Choose the region: Select the region where you want Google Cloud to run the infrastructure that will handle the requests coming from your agent’s tools (for example, you might choose europe-central2 here in Warsaw to match where we put the demo connector).
Okay, just click Create. And believe it or not, that’s the entire one-time setup needed! With this ExecuteConnection flow created, the Google Agent Development Kit is now ready to use it and work with any of the hundreds of connectors available in the Integration Connectors service, whenever you decide to use them as tools for your agents.
Summary:
The post introduces Google’s new open-source Agent Development Kit (ADK) for building multi-agent AI applications. A key highlight is ADK’s native integration with GCP Integration Connectors, which allows agents to use “Tools” that don’t just read data but can actively perform actions across over 100 different Google and third-party systems in compliance with enterprise security standard.
We walk through a demo using Google Drive:
- A GCP Connection to Google Drive is created (specifying location, logging, and authentication, including the important Enable Authentication Override setting for using end-user permissions).
- This connection is represented as a Tool within the ADK code using ApplicationIntegrationToolset, giving it a name and instructions for the agent, and specifying allowed actions (like listing files).
- An Agent is defined in ADK, equipped with the newly created GDrive tool.
- A Session and Runner are set up to facilitate interaction with the agent.
- The agent is asked to “list files on my gdrive”, successfully uses the tool, and returns the correct list of files, verified against the author’s actual GDrive.
Crucially, the post emphasizes a vital one-time setup required for this functionality to work: creating a specific Application Integration flow named exactly ExecuteConnection from the “Connection Tool” template within the GCP Application Integration service. This flow acts as a necessary bridge, enabling ADK to trigger any configured connector tool. Once this single ExecuteConnection flow is created and deployed, the ADK framework is ready to leverage the full power of GCP Integration Connectors as actionable tools for agents.