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

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Google Gemini API > Returns Fraud Detection Agent

Returns Fraud Detection Agent

Author: Venkata Sudhakar

ShopMax India processes thousands of return requests each month. Most are genuine, but a small percentage are fraudulent - wardrobing (using a product and returning it), return without original packaging, or serial returners gaming the refund policy. Manually reviewing every return is not scalable. An agent that scores each return request using behavioural signals catches fraud early while keeping the experience smooth for honest customers.

This tutorial builds a Returns Fraud Detection Agent using ADK and Gemini. The agent analyses a return request against purchase history, return frequency, item condition flags, and timing patterns to produce a fraud risk score with a recommended action: approve, flag for review, or reject.

The below example shows the fraud scoring pipeline applied to ShopMax India return requests.

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

# --- Customer history database ---
CUSTOMERS = {
    "CUST-001": {
        "name": "Rajesh Kumar",
        "city": "Mumbai",
        "total_orders": 14,
        "returns_last_12m": 1,
        "account_age_days": 720,
    },
    "CUST-002": {
        "name": "Priya Mehta",
        "city": "Bangalore",
        "total_orders": 6,
        "returns_last_12m": 5,
        "account_age_days": 180,
    },
    "CUST-003": {
        "name": "Anil Sharma",
        "city": "Delhi",
        "total_orders": 3,
        "returns_last_12m": 3,
        "account_age_days": 45,
    },
}

# Return risk signal weights
SIGNAL_WEIGHTS = {
    "high_return_rate": 30,        # returns > 50% of orders
    "new_account": 20,             # account age < 90 days
    "no_original_packaging": 15,   # returned without box
    "return_after_event": 15,      # returned just after Diwali/sale
    "high_value_item": 10,         # item value > Rs 30,000
    "multiple_returns_same_sku": 10,  # same SKU returned before
}

# --- Tool: score a return request ---
def score_return_request(
    customer_id: str,
    sku: str,
    item_value: float,
    has_original_packaging: bool,
    days_since_purchase: int,
    return_after_sale_event: bool = False,
) -> dict:
    """Score a return request for fraud risk.
    Args:
        customer_id: Customer identifier
        sku: Product SKU being returned
        item_value: Item value in Rs
        has_original_packaging: Whether original box is included
        days_since_purchase: Days between purchase and return request
        return_after_sale_event: Whether return follows a major sale event
    Returns:
        Fraud risk score and recommended action
    """
    if customer_id not in CUSTOMERS:
        return {"error": f"Unknown customer: {customer_id}"}
    cust = CUSTOMERS[customer_id]
    score = 0
    signals = []

# Signal: high return rate
    return_rate = cust["returns_last_12m"] / max(cust["total_orders"], 1)
    if return_rate > 0.5:
        score += SIGNAL_WEIGHTS["high_return_rate"]
        signals.append("high return rate ({:.0f}%)".format(return_rate * 100))

# Signal: new account
    if cust["account_age_days"] < 90:
        score += SIGNAL_WEIGHTS["new_account"]
        signals.append("new account ({} days old)".format(cust["account_age_days"]))

# Signal: no original packaging
    if not has_original_packaging:
        score += SIGNAL_WEIGHTS["no_original_packaging"]
        signals.append("no original packaging")

# Signal: returned after sale event
    if return_after_sale_event:
        score += SIGNAL_WEIGHTS["return_after_event"]
        signals.append("return follows sale event")

# Signal: high-value item
    if item_value > 30000:
        score += SIGNAL_WEIGHTS["high_value_item"]
        signals.append("high-value item (Rs {:,.0f})".format(item_value))

# Determine action
    if score >= 50:
        action = "REJECT"
    elif score >= 25:
        action = "FLAG_FOR_REVIEW"
    else:
        action = "APPROVE"

return {
        "customer_id": customer_id,
        "customer_name": cust["name"],
        "sku": sku,
        "fraud_score": score,
        "max_score": 100,
        "risk_signals": signals,
        "recommended_action": action,
        "days_since_purchase": days_since_purchase,
    }

# --- Agent setup ---
score_tool = FunctionTool(func=score_return_request)

agent = LlmAgent(
    name="returns_fraud_agent",
    model="gemini-2.0-flash",
    instruction="""You are a returns fraud detection agent for ShopMax India.
When given a return request, call score_return_request with all provided details.
Interpret the result:
  APPROVE: Process the return automatically, no friction for the customer.
  FLAG_FOR_REVIEW: Hold the return and notify the fraud team with the signal list.
  REJECT: Decline the return with a polite message, escalate to supervisor if customer pushes back.
Always explain which signals triggered the score and why the action was chosen.
Keep the tone factual - do not accuse the customer directly in your explanation.""",
    tools=[score_tool],
)

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

import asyncio

async def assess_return(query: str) -> str:
    session = await session_service.create_session(app_name="returns_fraud", user_id="returns_ops")
    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="returns_ops", session_id=session.id, new_message=msg):
        if event.is_final_response() and event.content:
            result = event.content.parts[0].text
    return result

query = (
    "Assess this return: customer CUST-002 wants to return SKU-1003 (Apple iPad, "
    "Rs 74000) purchased 12 days ago. No original box. Return request came in "
    "3 days after the Diwali sale ended."
)
response = asyncio.run(assess_return(query))
print(response)

It gives the following output,

Return Assessment - CUST-002 / SKU-1003

Customer: Priya Mehta (Bangalore)
Item: Apple iPad Air 11-inch  |  Value: Rs 74,000
Days since purchase: 12

Fraud Risk Score: 70 / 100

Signals triggered:
  [+30] High return rate - 5 returns on 6 orders (83%)
  [+15] No original packaging submitted
  [+15] Return follows Diwali sale event
  [+10] High-value item (Rs 74,000)

Recommended Action: REJECT

Reason: The combination of an extremely high return rate, absence of original
packaging, post-sale timing, and high item value places this request above
the automated rejection threshold. The returns team should contact the
customer to request further documentation before any refund is processed.

In production, store all return decisions and signal data in BigQuery for model retraining. Connect the rejection workflow to your OMS so approved returns auto-generate a pickup request, while flagged returns trigger a Pub/Sub event that pages the fraud team via a Cloud Function notification.

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