The Google Agent Developer Kit (ADK) provides some built-in tools that can be used in AI Agents, but we might also want to build custom tools. For instance, we might want tools that have access to private data or that can perform actions not specified in existing tools.
Using Google’s ADK, we can turn any Python function into a tool by following these guidelines:
- Write a python function;
- Follow the best practices for AI agent tools;
- Add the function to the agent’s
tools=[]list
Example: Currency Converter
We’re going to build the following agent that will convert currency for us, taking into account:
- the fee associated with different payment methods, and
- the current exchange rate
We’ll also include an agent tool (Calculation Agent) that can execute python code and perform the calculation directly, rather than asking the LLM to perform the calculation.
Here’s a diagram of what this looks like:
Define Python Functions
# Pay attention to the docstring, type hints, and return value.
def get_fee_for_payment_method(method: str) -> dict:
"""Looks up the transaction fee percentage for a given payment method.
This tool simulates looking up a company's internal fee structure based on
the name of the payment method provided by the user.
Args:
method: The name of the payment method. It should be descriptive,
e.g., "platinum credit card" or "bank transfer".
Returns:
Dictionary with status and fee information.
Success: {"status": "success", "fee_percentage": 0.02}
Error: {"status": "error", "error_message": "Payment method not found"}
"""
# This simulates looking up a company's internal fee structure.
fee_database = {
"platinum credit card": 0.02, # 2%
"gold debit card": 0.035, # 3.5%
"bank transfer": 0.01, # 1%
}
fee = fee_database.get(method.lower())
if fee is not None:
return {"status": "success", "fee_percentage": fee}
else:
return {
"status": "error",
"error_message": f"Payment method '{method}' not found",
}
def get_exchange_rate(base_currency: str, target_currency: str) -> dict:
"""Looks up and returns the exchange rate between two currencies.
Args:
base_currency: The ISO 4217 currency code of the currency you
are converting from (e.g., "USD").
target_currency: The ISO 4217 currency code of the currency you
are converting to (e.g., "EUR").
Returns:
Dictionary with status and rate information.
Success: {"status": "success", "rate": 0.93}
Error: {"status": "error", "error_message": "Unsupported currency pair"}
"""
# Static data simulating a live exchange rate API
# In production, this would call something like: requests.get("api.exchangerates.com")
rate_database = {
"usd": {
"eur": 0.93, # Euro
"jpy": 157.50, # Japanese Yen
"inr": 83.58, # Indian Rupee
}
}
# Input validation and processing
base = base_currency.lower()
target = target_currency.lower()
# Return structured result with status
rate = rate_database.get(base, {}).get(target)
if rate is not None:
return {"status": "success", "rate": rate}
else:
return {
"status": "error",
"error_message": f"Unsupported currency pair: {base_currency}/{target_currency}",
}Define a Calculation Agent
The calculation agent is being used as a tool here by the currency agent (which we’ll define next). Its purpose is to execute python code to perform a calculation rather than asking the LLM to perform the calculation. This is useful because sometimes LLMs fail when asked to calculate things, so we’re offloading the calculation to python.
calculation_agent = LlmAgent(
name="CalculationAgent",
model=Gemini(model="gemini-2.5-flash-lite", retry_options=retry_config),
instruction="""You are a specialized calculator that ONLY responds with Python code. You are forbidden from providing any text, explanations, or conversational responses.
Your task is to take a request for a calculation and translate it into a single block of Python code that calculates the answer.
**RULES:**
1. Your output MUST be ONLY a Python code block.
2. Do NOT write any text before or after the code block.
3. The Python code MUST calculate the result.
4. The Python code MUST print the final result to stdout.
5. You are PROHIBITED from performing the calculation yourself. Your only job is to generate the code that will perform the calculation.
Failure to follow these rules will result in an error.
""",
code_executor=BuiltInCodeExecutor(), # Use the built-in Code Executor Tool. This gives the agent code execution capabilities
)Define our Currency Agent
Next, we want to define our currency agent and give it access to all of the tools we just defined.
enhanced_currency_agent = LlmAgent(
name="enhanced_currency_agent",
model=Gemini(model="gemini-2.5-flash-lite", retry_options=retry_config),
# Updated instruction
instruction="""You are a smart currency conversion assistant. You must strictly follow these steps and use the available tools.
For any currency conversion request:
1. Get Transaction Fee: Use the get_fee_for_payment_method() tool to determine the transaction fee.
2. Get Exchange Rate: Use the get_exchange_rate() tool to get the currency conversion rate.
3. Error Check: After each tool call, you must check the "status" field in the response. If the status is "error", you must stop and clearly explain the issue to the user.
4. Calculate Final Amount (CRITICAL): You are strictly prohibited from performing any arithmetic calculations yourself. You must use the calculation_agent tool to generate Python code that calculates the final converted amount. This
code will use the fee information from step 1 and the exchange rate from step 2.
5. Provide Detailed Breakdown: In your summary, you must:
* State the final converted amount.
* Explain how the result was calculated, including:
* The fee percentage and the fee amount in the original currency.
* The amount remaining after deducting the fee.
* The exchange rate applied.
""",
tools=[
get_fee_for_payment_method,
get_exchange_rate,
AgentTool(agent=calculation_agent), # Using another agent as a tool!
],
)