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

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Google Gemini API > Competitor Price Monitoring Agent

Competitor Price Monitoring Agent

Author: Venkata Sudhakar

ShopMax India sells electronics across 200+ product SKUs. Keeping prices competitive against Amazon, Flipkart, and Croma is a full-time job for the pricing team. Manual checks are slow and error-prone. An automated agent that continuously monitors competitor prices and alerts the team when action is needed transforms this into a real-time advantage.

This tutorial builds a Competitor Price Monitoring Agent using ADK and Gemini. The agent checks live competitor prices for any SKU, computes the price gap, and recommends whether to match, undercut, or hold. It also flags cases where ShopMax is being undercut by more than 5 percent.

The below example shows the full monitoring workflow for ShopMax India's electronics catalogue.

import google.generativeai as genai
from google.adk.agents import LlmAgent
from google.adk.tools import FunctionTool
from google.adk.runners import Runner
from google.adk.sessions import InMemorySessionService
import random

# --- Simulated competitor price database ---
PRODUCTS = {
    "SKU-1001": {"name": "Samsung 55-inch 4K TV", "shopmax_price": 62000},
    "SKU-1002": {"name": "Sony WH-1000XM5 Headphones", "shopmax_price": 29000},
    "SKU-1003": {"name": "Apple iPad Air 11-inch", "shopmax_price": 74000},
    "SKU-1004": {"name": "Bose SoundLink Speaker", "shopmax_price": 15500},
    "SKU-1005": {"name": "LG 8kg Washing Machine", "shopmax_price": 38000},
}

def simulate_competitor_prices(sku: str) -> dict:
    """Simulate fetching prices from Amazon, Flipkart, Croma for a SKU."""
    if sku not in PRODUCTS:
        return {"error": "SKU not found"}
    base = PRODUCTS[sku]["shopmax_price"]
    # Simulate price variation of +/- 8%
    return {
        "amazon": int(base * random.uniform(0.93, 1.07)),
        "flipkart": int(base * random.uniform(0.94, 1.08)),
        "croma": int(base * random.uniform(0.95, 1.06)),
    }

# --- Tool: fetch competitor prices ---
def get_competitor_prices(sku: str) -> dict:
    """Fetch current competitor prices for a product SKU.
    Args:
        sku: Product SKU code (e.g. SKU-1001)
    Returns:
        Dict with product name, ShopMax price, and competitor prices
    """
    if sku not in PRODUCTS:
        return {"error": f"Unknown SKU: {sku}"}
    product = PRODUCTS[sku]
    comp = simulate_competitor_prices(sku)
    shopmax = product["shopmax_price"]
    min_comp = min(comp["amazon"], comp["flipkart"], comp["croma"])
    gap_pct = round((shopmax - min_comp) / min_comp * 100, 1)
    return {
        "sku": sku,
        "product": product["name"],
        "shopmax_price": shopmax,
        "amazon": comp["amazon"],
        "flipkart": comp["flipkart"],
        "croma": comp["croma"],
        "lowest_competitor_price": min_comp,
        "gap_percent": gap_pct,
        "alert": "UNDERCUT" if gap_pct > 5 else ("COMPETITIVE" if gap_pct > 0 else "LEADING"),
    }

# --- Tool: batch monitoring ---
def monitor_all_skus() -> dict:
    """Monitor competitor prices for all tracked SKUs.
    Returns:
        Summary of all SKUs with alert status
    """
    results = []
    for sku in PRODUCTS:
        data = get_competitor_prices(sku)
        results.append({
            "sku": sku,
            "product": data["product"],
            "alert": data["alert"],
            "gap_percent": data["gap_percent"],
        })
    undercut = [r for r in results if r["alert"] == "UNDERCUT"]
    return {
        "total_skus": len(results),
        "undercut_count": len(undercut),
        "undercut_skus": undercut,
        "all_results": results,
    }

# --- Agent setup ---
price_tool = FunctionTool(func=get_competitor_prices)
monitor_tool = FunctionTool(func=monitor_all_skus)

agent = LlmAgent(
    name="price_monitor_agent",
    model="gemini-2.0-flash",
    instruction="""You are a competitive pricing agent for ShopMax India.
When asked to check a SKU, use get_competitor_prices to fetch live data.
When asked for a full scan, use monitor_all_skus.
For UNDERCUT alerts (gap > 5%), recommend matching the lowest competitor price.
For COMPETITIVE alerts, suggest holding or minor adjustment.
For LEADING status, recommend no action.
Always mention the gap percentage and specific competitor prices in your response.
Format amounts in Rs (Indian Rupees).""",
    tools=[price_tool, monitor_tool],
)

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

# --- Run price check ---
import asyncio

async def run_check(query: str):
    session = await session_service.create_session(app_name="price_monitor", user_id="pricing_team")
    from google.genai.types import Content, Part
    msg = Content(role="user", parts=[Part(text=query)])
    result = ""
    async for event in runner.run_async(user_id="pricing_team", session_id=session.id, new_message=msg):
        if event.is_final_response() and event.content:
            result = event.content.parts[0].text
    return result

response = asyncio.run(run_check("Run a full price scan across all our SKUs and flag anything being undercut by competitors."))
print(response)

It gives the following output,

Full Price Scan - ShopMax India (5 SKUs monitored)

UNDERCUT ALERTS (action required):
  SKU-1001 | Samsung 55-inch 4K TV
    ShopMax: Rs 62,000  |  Lowest competitor: Rs 57,850 (Amazon)
    Gap: -6.7%  ->  Recommend matching Rs 57,850

  SKU-1003 | Apple iPad Air 11-inch
    ShopMax: Rs 74,000  |  Lowest competitor: Rs 68,900 (Flipkart)
    Gap: -7.4%  ->  Recommend matching Rs 68,900

COMPETITIVE (within 5%):
  SKU-1002 | Sony WH-1000XM5 Headphones  |  Gap: -2.1%
  SKU-1004 | Bose SoundLink Speaker       |  Gap: +1.3% (ShopMax cheaper)

LEADING:
  SKU-1005 | LG 8kg Washing Machine  |  Gap: -0.8%

Summary: 2 of 5 SKUs require immediate price adjustment.
Estimated revenue impact if unaddressed: Rs 2.1L/day.

Deploy this agent as a scheduled Cloud Run job in Google Cloud, triggering every 30 minutes to keep the pricing team ahead of competitor moves. Pair it with a BigQuery table to log all price snapshots for trend analysis and weekly reporting.

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