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

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Google Gemini API > ADK Tool Composition Patterns

ADK Tool Composition Patterns

Author: Venkata Sudhakar

Tool composition means building complex operations from simpler tool primitives. For ShopMax India, checking order fulfilment readiness requires stock verification, payment confirmation, and warehouse assignment - three separate tools that together answer one customer question. ADK agents orchestrate these automatically, but you can also create composed tools that bundle related operations.

The example shows two patterns: primitive tools that do one thing, and a composed tool that calls multiple primitives and aggregates their results. The agent can use either the primitives directly or the composed tool depending on what the query requires.

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

# --- Primitive tools ---

def check_stock(product_id: str) -> dict:
    """Check stock level for a ShopMax India product."""
    stock = {"SKU-001": 45, "SKU-002": 0, "SKU-003": 12}
    qty = stock.get(product_id, -1)
    return {"product_id": product_id, "in_stock": qty > 0, "quantity": qty}

def check_payment_status(order_id: str) -> dict:
    """Check payment status for a ShopMax India order."""
    payments = {
        "ORD-101": {"status": "confirmed", "amount_rs": 64999},
        "ORD-102": {"status": "pending",   "amount_rs": 74999},
    }
    return payments.get(order_id, {"status": "not_found"})

def assign_warehouse(product_id: str, city: str) -> dict:
    """Assign the nearest ShopMax India warehouse for a product and city."""
    warehouses = {
        "Mumbai":    "Pune Warehouse (45 km)",
        "Delhi":     "Gurgaon Warehouse (28 km)",
        "Bangalore": "Whitefield Warehouse (12 km)",
    }
    wh = warehouses.get(city, "Delhi Warehouse (default)")
    return {"product_id": product_id, "city": city, "assigned_warehouse": wh}

# --- Composed tool: full fulfilment readiness check ---

def check_fulfilment_readiness(order_id: str, product_id: str, city: str) -> dict:
    """Check if a ShopMax India order is ready for fulfilment - stock, payment, and warehouse."""
    stock   = check_stock(product_id)
    payment = check_payment_status(order_id)
    wh      = assign_warehouse(product_id, city) if stock["in_stock"] else {}

ready = stock["in_stock"] and payment.get("status") == "confirmed"
    return {
        "order_id":  order_id,
        "ready":     ready,
        "stock":     stock,
        "payment":   payment,
        "warehouse": wh
    }

agent = LlmAgent(
    name="shopmax_fulfilment_agent",
    model="gemini-2.0-flash",
    tools=[
        FunctionTool(check_stock),
        FunctionTool(check_payment_status),
        FunctionTool(assign_warehouse),
        FunctionTool(check_fulfilment_readiness),
    ],
    instruction=(
        "You are a ShopMax India fulfilment agent. "
        "Use check_fulfilment_readiness for full order checks. "
        "Use individual tools for specific queries about stock, payment, or warehouse only."
    )
)

session_service = InMemorySessionService()
runner = Runner(agent=agent, session_service=session_service, app_name="shopmax")

def ask(uid: str, query: str):
    session = session_service.create_session(app_name="shopmax", user_id=uid)
    events = list(runner.run(
        user_id=uid,
        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"Q: {query}\nA: {part.text.strip()[:200]}\n")

ask("u1", "Is order ORD-101 for SKU-001 ready to ship to Mumbai?")
ask("u2", "Is order ORD-102 for SKU-001 ready to ship to Bangalore?")
ask("u3", "Just check stock for SKU-002")

It gives the following output,

Q: Is order ORD-101 for SKU-001 ready to ship to Mumbai?
A: Order ORD-101 is ready for fulfilment. Stock confirmed (45 units at SKU-001),
payment of Rs 64,999 confirmed. Assigned to Pune Warehouse (45 km from Mumbai)
for dispatch.

Q: Is order ORD-102 for SKU-001 ready to ship to Bangalore?
A: Order ORD-102 is NOT ready. Stock is available (45 units), but payment status
is still pending at Rs 74,999. The order cannot be dispatched until payment is
confirmed.

Q: Just check stock for SKU-002
A: SKU-002 is currently out of stock at ShopMax India. No units are available
in any warehouse at this time.

For the first two queries the agent used the composed check_fulfilment_readiness tool, which ran all three primitives internally and returned a single aggregated result. For the third query, the agent correctly identified that only check_stock was needed and called just that primitive. This is the power of giving the agent both primitive and composed tools - it selects the right level of abstraction for each query.

For ShopMax India production, design your tool library in three layers: primitive tools (single data source, single operation), composed tools (multi-source, single domain), and orchestration tools (cross-domain workflows). Keep primitives thin and fast so they can be tested independently. Composed tools should include their own error handling so the agent receives a clean result even if one primitive fails - for example, returning warehouse as null rather than propagating an exception when warehouse assignment fails.

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