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

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Google Gemini API > ADK Batch Agent Processing

ADK Batch Agent Processing

Author: Venkata Sudhakar

Many business workflows require processing hundreds or thousands of items through an AI agent - daily report generation, bulk product categorisation, nightly risk scoring, or end-of-day reconciliation. ADK agents can be run in batch mode using Python async concurrency, processing items in parallel while respecting API rate limits.

ShopMax India needs to process 500+ product listings each night - classifying items, generating SEO descriptions, and flagging policy violations. Running these sequentially would take hours. Batch agent processing completes the same work in minutes using concurrent Gemini calls with controlled throughput.

The below example shows a batch agent that processes a list of product listings concurrently with rate limiting and error tracking.

import asyncio
import google.generativeai as genai
from dataclasses import dataclass, field
from typing import List, Optional

genai.configure(api_key="your-api-key")

@dataclass
class BatchResult:
    item_id: str
    success: bool
    output: Optional[str] = None
    error: Optional[str] = None

@dataclass
class BatchReport:
    total: int = 0
    succeeded: int = 0
    failed: int = 0
    results: List[BatchResult] = field(default_factory=list)

async def process_single(semaphore, model, item):
    # Semaphore limits concurrent API calls
    async with semaphore:
        try:
            prompt = f"""Classify this ShopMax India product listing:
Product: {item["name"]}
Price: Rs {item["price"]}
Description: {item["description"]}

Return: category, subcategory, policy_violation (true/false), seo_title (max 60 chars).
Format: category|subcategory|policy_violation|seo_title"""

response = await asyncio.to_thread(
                model.generate_content, prompt
            )
            return BatchResult(
                item_id=item["id"],
                success=True,
                output=response.text.strip()
            )
        except Exception as e:
            return BatchResult(
                item_id=item["id"],
                success=False,
                error=str(e)
            )

async def run_batch(items, max_concurrent=10):
    model = genai.GenerativeModel("gemini-2.0-flash")
    semaphore = asyncio.Semaphore(max_concurrent)
    tasks = [process_single(semaphore, model, item) for item in items]
    results = await asyncio.gather(*tasks)

report = BatchReport(total=len(items))
    for r in results:
        report.results.append(r)
        if r.success:
            report.succeeded += 1
        else:
            report.failed += 1
    return report

# Sample product batch
products = [
    {"id": "P001", "name": "Samsung 65-inch 4K TV", "price": 75000,
     "description": "QLED display, HDR10+, smart TV with voice control"},
    {"id": "P002", "name": "iPhone 15 Pro", "price": 134900,
     "description": "A17 Pro chip, titanium design, 48MP camera system"},
    {"id": "P003", "name": "Dell XPS 15 Laptop", "price": 145000,
     "description": "Intel Core i7, 32GB RAM, OLED display, 1TB SSD"},
]

report = asyncio.run(run_batch(products, max_concurrent=5))
print(f"Batch complete: {report.succeeded}/{report.total} succeeded, {report.failed} failed")
for r in report.results:
    if r.success:
        print(f"  {r.item_id}: {r.output}")
    else:
        print(f"  {r.item_id}: ERROR - {r.error}")

It gives the following output,

Batch complete: 3/3 succeeded, 0 failed
  P001: Electronics|Televisions|false|Samsung 65-inch QLED 4K Smart TV HDR10+
  P002: Electronics|Smartphones|false|Apple iPhone 15 Pro Titanium 48MP Camera
  P003: Electronics|Laptops|false|Dell XPS 15 OLED i7 32GB 1TB SSD Laptop

The semaphore controls throughput so you stay within Gemini API rate limits. Scale max_concurrent based on your quota tier. For large batches (10,000+ items), chunk the list and process in waves, persisting results to a database between chunks. Add exponential backoff in the exception handler to retry transient quota errors automatically.

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