	In Browser
	StumbleUpon
	del.icio.us
	Google
	Google Buzz
	reddit
	LinkedIn

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Google Gemini API > ADK Dynamic Tool Selection

ADK Dynamic Tool Selection

Author: Venkata Sudhakar

Loading all tools into every agent session is wasteful and can confuse the model when the tool list is large. For ShopMax India, a customer agent needs pricing and stock tools, but a warehouse agent needs dispatch and logistics tools. Dynamic tool selection loads only the tools relevant to the current user role and query context, keeping the model focused and reducing token overhead.

The pattern below classifies the incoming query to determine intent, then builds an agent with only the tools appropriate for that intent. This replaces one large agent with many small focused agents selected at dispatch time.

from google.adk.agents import LlmAgent
from google.adk.tools import FunctionTool
from google.adk.sessions import InMemorySessionService
from google.adk.runners import Runner
from google.genai.types import Content, Part

# --- Tool definitions ---

def check_stock(product_id: str) -> dict:
    """Check stock levels for a ShopMax India product."""
    return {"product_id": product_id, "stock": 88, "warehouse": "Pune"}

def get_price(product_id: str) -> dict:
    """Get product price in Indian Rupees."""
    return {"product_id": product_id, "price_rs": 64999}

def get_order_status(order_id: str) -> dict:
    """Get the current status of a ShopMax India order."""
    return {"order_id": order_id, "status": "Dispatched", "eta": "2 days"}

def initiate_return(order_id: str, reason: str) -> dict:
    """Initiate a return for a ShopMax India order."""
    return {"order_id": order_id, "return_id": "RET-7712", "status": "initiated", "reason": reason}

def get_dispatch_queue() -> dict:
    """Get the current dispatch queue for ShopMax India warehouse staff."""
    return {"pending_dispatches": 14, "urgent": 3, "warehouse": "Pune"}

def update_stock(product_id: str, quantity: int) -> dict:
    """Update stock count for a product in the ShopMax India warehouse system."""
    return {"product_id": product_id, "new_quantity": quantity, "updated": True}

# --- Tool registry by intent ---
TOOL_REGISTRY = {
    "product_query":  [check_stock, get_price],
    "order_query":    [get_order_status, initiate_return],
    "warehouse_ops":  [get_dispatch_queue, update_stock, check_stock],
}

INSTRUCTIONS = {
    "product_query":  "You are a ShopMax India product advisor. Answer stock and price queries.",
    "order_query":    "You are a ShopMax India order support agent. Handle order status and returns.",
    "warehouse_ops":  "You are a ShopMax India warehouse assistant. Help with dispatch and stock updates.",
}

def classify_intent(query: str) -> str:
    q = query.lower()
    if any(w in q for w in ["price", "stock", "available", "product", "sku"]):
        return "product_query"
    if any(w in q for w in ["order", "return", "status", "deliver", "dispatch"]):
        return "order_query"
    if any(w in q for w in ["warehouse", "queue", "update stock", "dispatch queue"]):
        return "warehouse_ops"
    return "product_query"  # default

def handle(user_id: str, query: str):
    intent = classify_intent(query)
    tools = [FunctionTool(fn) for fn in TOOL_REGISTRY[intent]]

agent = LlmAgent(
        name=f"shopmax_{intent}_agent",
        model="gemini-2.0-flash",
        tools=tools,
        instruction=INSTRUCTIONS[intent]
    )
    session_service = InMemorySessionService()
    runner = Runner(agent=agent, session_service=session_service, app_name="shopmax")
    session = session_service.create_session(app_name="shopmax", user_id=user_id)
    events = list(runner.run(
        user_id=user_id,
        session_id=session.id,
        new_message=Content(parts=[Part(text=query)])
    ))
    for event in events:
        if hasattr(event, "content") and event.content:
            for part in event.content.parts:
                if hasattr(part, "text") and part.text:
                    print(f"[{intent}] {part.text.strip()[:160]}")

handle("u1", "What is the price of SKU-7821?")
print()
handle("u2", "What is the status of order ORD-551?")
print()
handle("u3", "How many orders are in the dispatch queue?")

It gives the following output,

[product_query] SKU-7821 is currently priced at Rs 64,999 with 88 units in
stock at the Pune warehouse.

[order_query] Order ORD-551 has been dispatched and is expected to arrive
within 2 days.

[warehouse_ops] There are currently 14 pending dispatches in the Pune warehouse
queue, with 3 marked as urgent priority.

Each query was routed to an agent with only the tools it needed - the product query agent had no access to return or dispatch tools, and the warehouse agent had no access to customer-facing order tools. This prevents the model from accidentally using the wrong tool, reduces input token count (fewer tool descriptions in the prompt), and makes each agent easier to test in isolation.

For ShopMax India production, replace the keyword classifier with a Gemini call that classifies intent from the query text - this handles ambiguous or complex queries more reliably than keyword matching. Cache the classification result in the session state so follow-up queries in the same conversation reuse the same tool set without re-classifying. Use Cloud Armor to enforce that warehouse_ops tool access is restricted to requests originating from internal ShopMax India IP ranges.

Send your comments, suggestions or queries regarding this site to [email protected].