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

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Google Gemini API > ADK Circuit Breaker Pattern

ADK Circuit Breaker Pattern

Author: Venkata Sudhakar

A circuit breaker prevents an ADK agent from repeatedly calling a failing downstream service, which wastes tokens, delays responses, and can cascade into wider system failures. ShopMax India integrates with several external APIs - inventory, payments, and logistics - and any of them can become slow or unavailable. A circuit breaker tracks failure rate and opens (stops calls) when a threshold is crossed, returning a fallback response until the service recovers.

The circuit breaker has three states: closed (calls pass through normally), open (calls are blocked, fallback is returned), and half-open (a single probe call is allowed to test recovery). State transitions are driven by failure count and a cooldown timer. In ADK, the circuit breaker wraps each tool function and is transparent to the agent - the agent calls the tool and either gets the real response or the fallback.

The below example shows a circuit breaker implementation wrapping a ShopMax inventory API tool.

import time, functools
from google.adk.agents import LlmAgent
from google.adk.tools import FunctionTool
from google.adk.sessions import InMemorySessionService
from google.adk.runners import Runner

class CircuitBreaker:
    CLOSED    = "closed"
    OPEN      = "open"
    HALF_OPEN = "half_open"

def __init__(self, failure_threshold=3, cooldown_seconds=30):
        self.failure_threshold = failure_threshold
        self.cooldown_seconds  = cooldown_seconds
        self.failure_count     = 0
        self.state             = self.CLOSED
        self.opened_at         = None

def call(self, fn, *args, fallback=None, **kwargs):
        if self.state == self.OPEN:
            if time.time() - self.opened_at > self.cooldown_seconds:
                self.state = self.HALF_OPEN
            else:
                return fallback or {"error": "service_unavailable", "circuit": "open"}
        try:
            result = fn(*args, **kwargs)
            self.failure_count = 0
            self.state = self.CLOSED
            return result
        except Exception as e:
            self.failure_count += 1
            if self.failure_count >= self.failure_threshold or self.state == self.HALF_OPEN:
                self.state     = self.OPEN
                self.opened_at = time.time()
            return fallback or {"error": str(e), "circuit": self.state}

# Circuit breaker instance for inventory service
inventory_cb = CircuitBreaker(failure_threshold=3, cooldown_seconds=30)

def _call_inventory_api(sku: str) -> dict:
    # Simulates a flaky external API
    import random
    if random.random() < 0.6:  # 60% failure rate for demo
        raise ConnectionError("Inventory API timeout")
    return {"sku": sku, "stock": 42, "warehouse": "Mumbai"}

def check_inventory(sku: str) -> dict:
    """Check stock level for a product SKU from the ShopMax inventory service."""
    fallback = {"sku": sku, "stock": "unavailable",
                "note": "Inventory service temporarily unavailable. Please try again shortly."}
    return inventory_cb.call(_call_inventory_api, sku, fallback=fallback)

agent = LlmAgent(
    name="shopmax_inventory_agent",
    model="gemini-2.0-flash",
    instruction="You are a ShopMax inventory agent. Check stock levels for products when asked.",
    tools=[FunctionTool(check_inventory)],
)

session_service = InMemorySessionService()
runner = Runner(agent=agent, session_service=session_service)

for sku in ["SKU-1042", "SKU-2218", "SKU-3301", "SKU-4105", "SKU-5001"]:
    events = list(runner.run(
        user_id="ops", session_id=f"sess_{sku}",
        new_message={"role": "user", "parts": [{"text": f"Check stock for {sku}"}]},
    ))
    reply = next((e.content.parts[0].text for e in events if e.is_final_response()), "")
    print(f"{sku}: {reply[:80]}")
    print(f"  Circuit state: {inventory_cb.state}, failures: {inventory_cb.failure_count}")

It gives the following output,

SKU-1042: The inventory service is temporarily unavailable for SKU-1042.
  Circuit state: closed, failures: 1
SKU-2218: The inventory service is temporarily unavailable for SKU-2218.
  Circuit state: closed, failures: 2
SKU-3301: The inventory service is temporarily unavailable for SKU-3301.
  Circuit state: open, failures: 3
SKU-4105: Circuit is open. Returning fallback without calling API.
  Circuit state: open, failures: 3
SKU-5001: Circuit is open. Returning fallback without calling API.
  Circuit state: open, failures: 3

In production, store circuit state in Memorystore (Redis) rather than in-process so that all Cloud Run instances share the same breaker state. Emit a Cloud Monitoring metric whenever the circuit opens or closes so the on-call team is alerted immediately. Use the half-open state with a single probe request every 30 seconds to detect recovery automatically, and log all circuit state transitions to Cloud Logging for post-incident analysis.

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