Compliance Audit Agent

def detect_anomalies(transactions):
    """
    Detect statistical anomalies based on transaction amounts.
    Returns list of(transaction, reason) for anomalies.
    """
    anomalies = []
    amounts = [t["amount"] for t in transactions if isinstance(t.get("amount"), (int, float))]
    if not amounts:
        return anomalies
    mean_val = statistics.mean(amounts)
    stdev_val = statistics.stdev(amounts) if len(amounts) > 1 else 0
    for t in transactions:
        if isinstance(t.get("amount"), (int, float)) and stdev_val > 0:
            z_score = abs((t["amount"] - mean_val) / stdev_val)
            if z_score > 3:
                anomalies.append((t, f"Amount anomaly(z-score {z_score:.2f})"))
    return anomalies

def identify_patterns(transactions):
    """
    Identify recurring patterns(e.g., frequent same amount, repeated account codes).
    Returns dict of detected patterns.
    """
    patterns = {"frequent_amounts": {}, "frequent_accounts": {}}
    for t in transactions:
        amt = t.get("amount")
        acc = t.get("account_code")
        if amt:
            patterns["frequent_amounts"][amt] = patterns["frequent_amounts"].get(amt, 0) + 1
        if acc:
            patterns["frequent_accounts"][acc] = patterns["frequent_accounts"].get(acc, 0) + 1
    patterns["frequent_amounts"] = {k: v for k, v in patterns["frequent_amounts"].items() if v >= 3}
    patterns["frequent_accounts"] = {k: v for k, v in patterns["frequent_accounts"].items() if v >= 3}
    return patterns

def check_compliance(transaction, standards):
    """
    Check transaction against a set of compliance rules.
    Returns list of violations.
    """
    violations = []
    if "max_amount" in standards and transaction.get("amount") > standards["max_amount"]:
        violations.append(f"Amount exceeds maximum allowed({standards['max_amount']})")
    if "prohibited_accounts" in standards and transaction.get("account_code") in standards["prohibited_accounts"]:
        violations.append(f"Use of prohibited account code: {transaction.get('account_code')}")
    return violations

def generate_compliance_report(transactions):
    """
    Generate a compliance report for all transactions.
    Returns dict with summary and violations.
    """
    report = {"total_transactions": len(transactions), "violations": [], "summary": ""}
    compliance_rules = {"max_amount": 100000, "prohibited_accounts": ["9999"]}
    for t in transactions:
        violations = check_compliance(t, compliance_rules)
        if violations:
            report["violations"].append({"transaction": t, "violations": violations})
    report["summary"] = f"Found {len(report['violations'])} transactions with compliance issues."
    return report

def cross_reference_regulatory_database(transaction, regulatory_db=None):
    """
    Cross-reference transaction with external regulatory database for compliance.
    Returns list of regulatory findings.
    """
    if regulatory_db is None:
        regulatory_db = {
            "suspicious_patterns": [
                {"pattern": "round_amounts", "threshold": 10000, "risk": "medium"},
                {"pattern": "frequent_small_amounts", "threshold": 100, "risk": "high"},
            ],
            "regulated_entities": ["12345", "67890"],
            "restricted_transactions": ["gambling", "cryptocurrency"],
        }
    findings = []
    amount = transaction.get("amount", 0)
    if amount >= 10000 and amount % 1000 == 0:
        findings.append("Large round amount detected - may require additional scrutiny")
    if amount <= 100:
        findings.append("Small amount transaction - monitor for structuring patterns")
    description = transaction.get("description", "").lower()
    for restricted in regulatory_db["restricted_transactions"]:
        if restricted in description:
            findings.append(f"Transaction description contains restricted term: {restricted}")
    return findings

def analyze_historical_compliance_trends(transactions, historical_data=None):
    """
    Analyze historical compliance trends and patterns over time.
    Returns dict with trend analysis and risk indicators.
    """
    if historical_data is None:
        historical_data = {
            "monthly_violations": [5, 3, 7, 2, 4, 6, 3, 5, 4, 3, 6, 4],
            "common_violation_types": ["amount_limit", "account_code", "duplicate"],
            "seasonal_patterns": {"Q4": "high", "Q1": "low", "Q2": "medium", "Q3": "medium"},
        }
    analysis = {"trend_direction": "", "risk_level": "", "seasonal_factors": [], "recommendations": []}
    violations = historical_data["monthly_violations"]
    if len(violations) >= 2:
        recent_avg = sum(violations[-3:]) / 3
        older_avg = sum(violations[:-3]) / (len(violations) - 3) if len(violations) > 3 else violations[0]
        if recent_avg > older_avg * 1.2:
            analysis["trend_direction"] = "increasing"
            analysis["risk_level"] = "high"
            analysis["recommendations"].append("Implement stricter validation rules")
        elif recent_avg < older_avg * 0.8:
            analysis["trend_direction"] = "decreasing"
            analysis["risk_level"] = "low"
        else:
            analysis["trend_direction"] = "stable"
            analysis["risk_level"] = "medium"
    current_month = datetime.now().month
    if current_month in [10, 11, 12]:
        analysis["seasonal_factors"].append("Q4 typically shows higher violation rates")
        analysis["recommendations"].append("Increase monitoring during Q4")
    if "amount_limit" in historical_data["common_violation_types"]:
        analysis["recommendations"].append("Review and adjust amount limits")
    return analysis