How you can Use Google ADK for Constructing Brokers?

Trying to construct clever brokers with real-world capabilities? Use Google ADK for constructing brokers that may cause, delegate, and reply dynamically. This Google ADK tutorial walks you thru the steps to construct conversational brokers with Google ADK throughout completely different language fashions like Gemini and GPT. Whether or not you’re exploring Google ADK for AI brokers or interested in how one can create AI brokers utilizing Google ADK, this hands-on information will allow you to kickstart your journey into agentic improvement with ease and readability.

What’s the Agent Growth Package?

Agent Growth Package (ADK) is a versatile and modular framework for growing and deploying AI brokers. It may be used with widespread LLMs and open-source generative AI instruments and is designed to combine tightly with the Google ecosystem and Gemini fashions. ADK makes it simple to get began with easy brokers powered by Gemini fashions and Google AI instruments whereas offering the management and construction wanted for extra advanced agent architectures and orchestration.

Options of Google’s Agent Growth Package

1. Multi-Agent Structure: Compose brokers in parallel, sequential, or hierarchical workflows.
2. Versatile Orchestration: Route duties dynamically utilizing LLM-powered workflows.
3. Wealthy Instrument Ecosystem: Use built-in, customized, and third-party instruments seamlessly.
4. Mannequin-Agnostic: Helps Gemini, GPT-4o, Claude, Mistral, and extra.
5. Streaming Capabilities: Actual-time streaming for textual content, audio, and video.
6. Dev-Pleasant Tooling: CLI, net UI, visible debugging, and analysis instruments.
7. Reminiscence & State Administration: Constructed-in dealing with for session and long-term reminiscence.
8. Artifact Dealing with: Handle information, outputs, and binary information effortlessly.
9. Good Execution: Brokers can execute code and deal with multi-step planning.
10. Versatile Deployment: Run regionally, on Google Cloud (Vertex AI, Cloud Run), or through Docker.

Downside Assertion

As AI methods evolve from single-purpose instruments to collaborative, multi-agent ecosystems, builders want sensible steerage on constructing and orchestrating clever brokers that may talk, delegate, and adapt. To bridge this hole, we’ll construct a Climate Bot Group, a multi-agent system able to answering weather-related queries whereas additionally dealing with person interactions like greetings, farewells, and protected responses.

This hands-on challenge goals to display how one can:

• Design a modular multi-agent system utilizing Google’s Agent Growth Package (ADK).
• Combine a number of language fashions (e.g., Gemini, GPT, Claude) for activity specialization.
• Implement clever activity delegation throughout brokers.
• Handle session reminiscence for contextual continuity.
• Apply security mechanisms by structured callbacks.

By fixing this downside, you’ll achieve sensible expertise with ADK’s structure, orchestration, reminiscence administration, and security finest practices, laying the groundwork for extra advanced, real-world agentic purposes.

You’ll be able to check with the supplied Colab pocket book to information you thru the hands-on implementation.

Proposed Workflow

Conditions

Earlier than diving into the code, be sure you’ve accomplished the next setup steps:

1. Set-up your Surroundings & Set up ADK

Begin by creating and activating a digital surroundings to isolate your challenge dependencies:

# Create a digital surroundings

python -m venv .venv

Now that the surroundings has been created, we are able to lively it utilizing the next instructions:

# Activate the surroundings

# macOS/Linux:

supply .venv/bin/activate

# Home windows CMD:

.venvScriptsactivate.bat

# Home windows PowerShell:

.venvScriptsActivate.ps1

 As soon as your surroundings is activated, set up the Google AI Growth Package (ADK):

pip set up google-adk

2. Get hold of your API Keys

You’ll want API keys to work together with completely different AI fashions. Seize them from the next sources:

Steps to Construct Your Climate App

Step 1: Setup and Set up

Set up the required libraries for the challenge:

# Set up Google ADK and LiteLLM
!pip set up google-adk -q
!pip set up litellm -q

Import libraries:

import os

import asyncio

from google.adk.brokers import Agent

from google.adk.fashions.lite_llm import LiteLlm # For multi-model help

from google.adk.classes import InMemorySessionService

from google.adk.runners import Runner

from google.genai import varieties # For creating message Content material/Elements

import warnings

# Ignore all warnings

warnings.filterwarnings("ignore")

import logging

logging.basicConfig(degree=logging.ERROR)

Arrange API Keys:

# Gemini API Key

os.environ["GOOGLE_API_KEY"] = "YOUR_GOOGLE_API_KEY"

# OpenAI API Key

os.environ['OPENAI_API_KEY'] = “YOUR_OPENAI_API_KEY”

# Anthropic API Key

os.environ['ANTHROPIC_API_KEY'] = “YOUR_ANTHROPIC_API_KEY”

print("API Keys Set:")

print(f"Google API Key set: {'Sure' if os.environ.get('GOOGLE_API_KEY') and os.environ['GOOGLE_API_KEY'] != 'YOUR_GOOGLE_API_KEY' else 'No (REPLACE PLACEHOLDER!)'}")

print(f"OpenAI API Key set: {'Sure' if os.environ.get('OPENAI_API_KEY') and os.environ['OPENAI_API_KEY'] != 'YOUR_OPENAI_API_KEY' else 'No (REPLACE PLACEHOLDER!)'}")

print(f"Anthropic API Key set: {'Sure' if os.environ.get('ANTHROPIC_API_KEY') and os.environ['ANTHROPIC_API_KEY'] != 'YOUR_ANTHROPIC_API_KEY' else 'No (REPLACE PLACEHOLDER!)'}")

# Configure ADK to make use of API keys instantly (not Vertex AI for this multi-model setup)

os.environ["GOOGLE_GENAI_USE_VERTEXAI"] = "False"

Outline Mannequin Constants for simpler use:

MODEL_GEMINI_2_0_FLASH = "gemini-2.0-flash".

MODEL_GPT_4O = "openai/gpt-4o"

MODEL_CLAUDE_SONNET = "anthropic/claude-3-sonnet-20240229"

print("nEnvironment configured.")

Step 2: Outline Instruments

In ADK, Instruments are the practical constructing blocks that enable brokers to transcend simply producing textual content. They’re usually easy Python capabilities that may carry out actual actions, like fetching climate information, querying a database, or working calculations.

To start out, we’ll create a mock climate device to simulate climate lookups. This helps us concentrate on the agent’s construction without having exterior APIs. Later, we are able to simply swap it for an actual climate service.

Code:

def get_weather(metropolis: str) -> dict:
   """Retrieves the present climate report for a specified metropolis.


   Args:
       metropolis (str): The identify of the town (e.g., "Mumbai","Chennai","Delhi").


   Returns:
       dict: A dictionary containing the climate data.
             Features a 'standing' key ('success' or 'error').
             If 'success', features a 'report' key with climate particulars.
             If 'error', consists of an 'error_message' key.
   """
   # Finest Follow: Log device execution for simpler debugging
   print(f"--- Instrument: get_weather known as for metropolis: {metropolis} ---")


   city_normalized = metropolis.decrease().exchange(" ", "")  # Primary enter normalization


   mock_weather_db = {
       "delhi": {"standing": "success", "report": "The climate in Delhi is sunny with a temperature of 35°C."},
       "mumbai": {"standing": "success", "report": "It is humid in Mumbai with a temperature of 30°C."},
       "bangalore": {"standing": "success", "report": "Bangalore is experiencing gentle showers and a temperature of twenty-two°C."},
       "kolkata": {"standing": "success", "report": "Kolkata is partly cloudy with a temperature of 29°C."},
       "chennai": {"standing": "success", "report": "It is sizzling and humid in Chennai with a temperature of 33°C."},
   }


   if city_normalized in mock_weather_db:
       return mock_weather_db[city_normalized]
   else:
       return {"standing": "error", "error_message": f"Sorry, I haven't got climate data for '{metropolis}'."}


# Instance utilization
print(get_weather("Mumbai"))

Step 3: Defining the Agent

In ADK, an Agent is the core element that manages the dialog stream, connecting the person, the LLM, and the instruments it may well use.

To outline an agent, you’ll configure just a few important parameters: 

• identify: A singular identifier for the agent (e.g., “weather_agent_v1”).
• mannequin: The LLM the agent will use (e.g., MODEL_GEMINI_2_5_PRO).
• description: A brief abstract of what the agent does – essential for collaboration and delegation in multi-agent methods.
• instruction: Detailed conduct tips for the LLM, defining its persona, objectives, how one can use instruments, and how one can deal with edge circumstances.
• instruments: A listing of device capabilities (like [get_weather]) the agent can invoke.

 Code:

AGENT_MODEL=mannequin
weather_agent=Agent(
   identify="weather_agent_v1",
   mannequin=AGENT_MODEL,
   description="Gives climate data for particular cities.",
   instruction="You're a useful climate assistant. Your major purpose is to offer present climate experiences. "
               "When the person asks for the climate in a selected metropolis, "
               "you MUST use the 'get_weather' device to search out the data. "
               "Analyze the device's response: if the standing is 'error', inform the person politely concerning the error message. "
               "If the standing is 'success', current the climate 'report' clearly and concisely to the person. "
               "Solely use the device when a metropolis is talked about for a climate request.",
   instruments=[get_weather],


)

print(f"Agent '{weather_agent.identify}' created utilizing mannequin '{AGENT_MODEL}'.")

Step 4: Arrange Runner and Session Service

To deal with conversations and run the agent successfully, we want two key elements:

SessionService: This element retains monitor of every person’s dialog historical past and session state. A fundamental model known as InMemorySessionService shops all information in reminiscence, making it splendid for testing or light-weight apps. It logs each message exchanged in a session. We’ll dive into saving session information completely.

Runner: This acts because the mind of the system. It manages your entire interplay stream, taking in person enter, passing it to the correct agent, calling the LLM and any essential instruments, updating session information by the SessionService, and producing a stream of occasions that present what’s occurring throughout the interplay.

 Code: 

# @title Setup Session Service and Runner
# ---Session Administration ---
# Key Idea: SessionService shops dialog historical past & state.
# InMemorySessionService is an easy, non-persistent storage for this tutorial.


session_service=InMemorySessionService()


# Outline constants for figuring out the interplay context
APP_NAME="weathertutorial_app"
USER_ID="user_1"
SESSION_ID="session_001"


# Create the particular session the place the dialog will occur
session=session_service.create_session(
   app_name=APP_NAME,
   user_id=USER_ID,
   session_id=SESSION_ID,
)


print(f"Session created: App='{APP_NAME}', Person="{USER_ID}", Session='{SESSION_ID}'")


# ---Runner ---
# Key Idea: Runner orchestrates the agent execution loop.


runner=Runner(
   agent=weather_agent,
   app_name=APP_NAME,
   session_service=session_service
)


print(f"Runner created for agent '{runner.agent.identify}'.")

Step 5: Work together with the Agent

We’ll use ADK’s asynchronous Runner to speak to our agent and get its response. Since LLM and power calls can take time, dealing with them asynchronously ensures a easy, non-blocking expertise.

We’ll create a helper operate known as call_agent_async that does the next:

• Accepts a person question as enter
• Wraps it in ADK’s required Content material format
• Calls runner.run_async() with the session and message
• Iterates by the Occasion stream ADK returns these occasions and tracks every step (device name, response, and so forth.).
• Detects and prints the ultimate response utilizing occasion.is_final_response()

 Code:

# @title Outline Agent Interplay Operate
import asyncio
from google.genai import varieties # For creating message Content material/Elements


async def call_agent_async(question: str):
 """Sends a question to the agent and prints the ultimate response."""
 print(f"n>>> Person Question: {question}")


 # Put together the person's message in ADK format
 content material = varieties.Content material(position="person", components=[types.Part(text=query)])


 final_response_text = "Agent didn't produce a last response." # Default


 # Key Idea: run_async executes the agent logic and yields Occasions.
 # We iterate by occasions to search out the ultimate reply.
 async for occasion in runner.run_async(user_id=USER_ID, session_id=SESSION_ID, new_message=content material):
     # You'll be able to uncomment the road under to see *all* occasions throughout execution
     # print(f"  [Event] Writer: {occasion.writer}, Sort: {sort(occasion).__name__}, Remaining: {occasion.is_final_response()}, Content material: {occasion.content material}")


     # Key Idea: is_final_response() marks the concluding message for the flip.
     if occasion.is_final_response():
         if occasion.content material and occasion.content material.components:
            # Assuming textual content response within the first half
            final_response_text = occasion.content material.components[0].textual content
         elif occasion.actions and occasion.actions.escalate: # Deal with potential errors/escalations
            final_response_text = f"Agent escalated: {occasion.error_message or 'No particular message.'}"
         # Add extra checks right here if wanted (e.g., particular error codes)
         break # Cease processing occasions as soon as the ultimate response is discovered


 print(f"<<< Agent Response: {final_response_text}")

Step 6: Run the Dialog

Now that every thing’s arrange, it’s time to place our agent to the take a look at by sending just a few pattern queries.

We’ll:

• Wrap the async calls inside a most important() coroutine
• Use await to run the operate.

What to Anticipate:

• The person queries will likely be printed
• When the agent makes use of a device (like get_weather), you’ll see logs like:
  — Instrument: get_weather known as… —
• The agent will return a last response, even gracefully dealing with circumstances the place information isn’t obtainable (e.g., for “Paris”)

Code:

# @title Run the Preliminary Dialog


# # We want an async operate to await our interplay helper
# async def run_conversation():
#     await call_agent_async("What's the climate like in Mumbai")
#     await call_agent_async("How about Delhi?") # Anticipating the device's error message
#     await call_agent_async("Inform me the climate in CHennai")


# Execute the dialog utilizing await in an async context (like Colab/Jupyter)
await run_conversation()

 Output:

Additionally Learn: How you can Use OpenAI’s Responses API & Agent SDK?

Conclusion

Google’s Agent Growth Package (ADK) permits builders to create clever, multi-agent methods that transcend easy textual content technology. By constructing a climate bot, we realized key ADK ideas similar to device integration, agent orchestration, and session administration, all whereas leveraging the ability of Google’s Gemini. From defining clear, descriptive docstrings for instruments to orchestrating interactions by the Runner and SessionService, ADK supplies the flexibleness to construct production-ready brokers that may work together, be taught, and adapt. Whether or not you’re constructing chatbots, digital assistants, or multi-agent ecosystems, ADK gives the instruments to convey your imaginative and prescient to life.

Often Requested Questions