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

	Facebook
	Twitter
	Linkedin
	E-Mail

Generative AI > Google Gemini API > Fraud Detection Agent

Fraud Detection Agent

Author: Venkata Sudhakar

Online fraud costs Indian e-commerce platforms crores annually through COD refusals, chargeback abuse, and account takeovers. An ADK fraud detection agent scores each order against multiple risk signals before it reaches the warehouse, flagging suspicious orders for manual review without blocking legitimate customers.

The agent evaluates four risk dimensions: account age and history, order value vs typical spend, delivery address novelty, and order velocity (how many orders placed in a short window). A composite score determines whether to approve, review, or reject the order automatically.

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

def get_account_profile(user_id: str) -> dict:
    """Get ShopMax India account profile for fraud risk assessment."""
    profiles = {
        "u_ankit":  {"account_age_days": 3,   "total_orders": 1,  "avg_order_rs": 500,   "verified_mobile": True},
        "u_meena":  {"account_age_days": 720,  "total_orders": 48, "avg_order_rs": 12000, "verified_mobile": True},
        "u_rahul":  {"account_age_days": 30,   "total_orders": 3,  "avg_order_rs": 8000,  "verified_mobile": False},
    }
    return profiles.get(user_id, {"error": "User not found"})

def check_order_velocity(user_id: str) -> dict:
    """Check how many orders the user placed in the last 24 hours on ShopMax India."""
    velocity = {"u_ankit": 4, "u_meena": 1, "u_rahul": 2}
    orders_24h = velocity.get(user_id, 0)
    return {"user_id": user_id, "orders_last_24h": orders_24h, "high_velocity": orders_24h >= 3}

def check_address_risk(user_id: str, delivery_pincode: str) -> dict:
    """Check if the delivery address is new or matches a known fraud pincode pattern."""
    known_addresses = {
        "u_meena": ["400001", "400002"],
        "u_rahul": ["110001"],
    }
    HIGH_RISK_PINCODES = ["999999", "000000"]
    user_known = known_addresses.get(user_id, [])
    is_new_address = delivery_pincode not in user_known
    is_high_risk_pincode = delivery_pincode in HIGH_RISK_PINCODES
    return {
        "pincode": delivery_pincode,
        "is_new_address": is_new_address,
        "is_high_risk_pincode": is_high_risk_pincode
    }

def score_fraud_risk(account_age_days: int, total_orders: int, avg_order_rs: int,
                     order_value_rs: int, orders_last_24h: int, is_new_address: bool,
                     payment_method: str, verified_mobile: bool) -> dict:
    """Compute composite fraud risk score for a ShopMax India order."""
    score = 0
    reasons = []

if account_age_days < 7:
        score += 3; reasons.append("new account (<7 days)")
    if total_orders < 2:
        score += 2; reasons.append("first-time buyer")
    if order_value_rs > avg_order_rs * 5:
        score += 3; reasons.append("order value 5x above average spend")
    if payment_method == "COD" and order_value_rs > 20000:
        score += 2; reasons.append("high-value COD order")
    if orders_last_24h >= 3:
        score += 3; reasons.append("high order velocity (3+ orders/24h)")
    if is_new_address:
        score += 1; reasons.append("new delivery address")
    if not verified_mobile:
        score += 2; reasons.append("unverified mobile number")

if score >= 7:
        decision = "REJECT"
    elif score >= 4:
        decision = "REVIEW"
    else:
        decision = "APPROVE"

return {"fraud_score": score, "decision": decision, "risk_reasons": reasons}

agent = LlmAgent(
    name="shopmax_fraud_agent",
    model="gemini-2.0-flash",
    tools=[
        FunctionTool(get_account_profile),
        FunctionTool(check_order_velocity),
        FunctionTool(check_address_risk),
        FunctionTool(score_fraud_risk),
    ],
    instruction=(
        "You are a ShopMax India fraud detection agent. "
        "For each order: get account profile, check velocity, check address risk, "
        "then compute the fraud score. State the decision and reasons clearly."
    )
)

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

orders = [
    ("u_ankit", "400001", 74999, "COD"),
    ("u_meena", "400001", 8000,  "UPI"),
    ("u_rahul", "560001", 45000, "COD"),
]

for uid, pincode, value, payment in orders:
    session = session_service.create_session(app_name="shopmax", user_id="fraud_system")
    query = (f"Assess fraud risk for order by {uid}: "
             f"Rs {value}, payment={payment}, delivery pincode={pincode}")
    events = list(runner.run(
        user_id="fraud_system",
        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"[{uid}] {part.text.strip()[:220]}")
    print()

It gives the following output,

[u_ankit] Decision: REJECT (fraud score: 13)
Risk signals: new account (<7 days), first-time buyer, order value 5x above
average spend, high-value COD order, high order velocity (4 orders in 24h),
new delivery address.
Recommendation: Cancel order and flag account for manual review.

[u_meena] Decision: APPROVE (fraud score: 0)
No risk signals detected. Established customer, 720 days active,
48 previous orders. Order value within normal range. Approve for dispatch.

[u_rahul] Decision: REVIEW (fraud score: 5)
Risk signals: unverified mobile number, high-value COD (Rs 45,000),
new delivery address.
Recommendation: Hold for manual verification - contact customer to confirm order.

The agent correctly blocked Ankit (multiple high-risk signals including a 3-day-old account placing a Rs 74,999 COD order after 4 orders in 24 hours), approved Meena's routine purchase, and flagged Rahul for review due to the combination of unverified mobile and a high-value COD order to a new address.

For ShopMax India production, integrate this agent as a synchronous pre-dispatch check in the order processing pipeline. Call it via a Cloud Run endpoint after payment confirmation but before warehouse notification. If the decision is REVIEW, write the order to a fraud_review Firestore queue for the operations team. If REJECT, trigger an automated order cancellation and send the customer an SMS requesting them to contact support. Log all decisions and scores to BigQuery for weekly fraud trend analysis.

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