Update app.py

app.py

@@ -1,286 +1,336 @@
-import re
+import os
+from dotenv import load_dotenv
+import logging
+import pdfplumber
 import pandas as pd
 import numpy as np
+from transformers import pipeline
+from sklearn.ensemble import IsolationForest
+from sklearn.preprocessing import StandardScaler
+import uuid
 from datetime import datetime, timedelta
+import re
 import gradio as gr
-from simple_salesforce import Salesforce
-import warnings
-warnings.filterwarnings("ignore")
+from simple_salesforce import Salesforce, SalesforceAuthenticationFailed
+
+# Load environment variables from .env file
+load_dotenv()
+
+# Configure environment for CPU usage
+os.environ["CUDA_VISIBLE_DEVICES"] = ""  # Disable GPU usage
+os.environ["TF_ENABLE_ONEDNN_OPTS"] = "0"  # Disable oneDNN optimizations
+
+# Set up logging to suppress transformers warnings
+logging.getLogger("transformers").setLevel(logging.ERROR)
 
-# Salesforce connection (mocked for this example)
-def connect_to_salesforce():
-    return None  # Replace with actual Salesforce connection
+# Read Salesforce credentials from environment variables
+SF_USERNAME = os.getenv("SF_USERNAME")
+SF_PASSWORD = os.getenv("SF_PASSWORD")
+SF_SECURITY_TOKEN = os.getenv("SF_SECURITY_TOKEN")
+
+print(f"Salesforce login info: username={SF_USERNAME}")
+
+# Salesforce connection with error handling
+try:
+    sf = Salesforce(
+        username=SF_USERNAME,
+        password=SF_PASSWORD,
+        security_token=SF_SECURITY_TOKEN
+    )
+    print("Salesforce login successful.")
+except SalesforceAuthenticationFailed as e:
+    print(f"Salesforce authentication failed: {e}")
+    sf = None
+
+# Initialize Hugging Face NER pipeline (force CPU)
+ner_pipeline = pipeline("ner", model="dslim/bert-base-NER", tokenizer="dslim/bert-base-NER", device=-1)
+
+def extract_text_from_pdf(pdf_file):
+    """Extract text from a PDF invoice."""
+    try:
+        with pdfplumber.open(pdf_file) as pdf:
+            text = ""
+            for page in pdf.pages:
+                page_text = page.extract_text() or ""
+                text += page_text + "\n"
+        print("Extracted text:\n", text)  # Debug: Print extracted text
+        return text
+    except Exception as e:
+        return f"Error extracting text: {str(e)}"
 
-# Extract entities from OCR text
 def extract_entities(text):
-    invoice_number = None
-    vendor_name = None
-    invoice_date = None
-    total_amount = None
-
-    # Extract invoice number
-    invoice_number_pattern = r"(?:Invoice\s*(?:No|#|Number|Advice\s*No)\s*[:\-\s]*)([A-Za-z0-9\-]+)"
-    invoice_match = re.search(invoice_number_pattern, text, re.IGNORECASE)
-    if invoice_match:
-        invoice_number = invoice_match.group(1).strip()
-
-    # Extract vendor name
-    vendor_pattern = r"(?:Vendor\s*[:\-\s]*)([^\n]+)"
+    """Extract structured invoice details using flexible regex patterns."""
+    invoice_number = "Unknown"
+    vendor_name = "Unknown"
+    invoice_date = datetime.now().date()
+    total_amount = 0.0
+
+    # Flexible regex patterns to handle variations
+    invoice_num_pattern = r"(?:Invoice\s*(?:Number|No\.?|#)\s*[:\-\s]*)([\w-]+)"
+    vendor_pattern = r"(?:Vendor\s*(?:Name|Company)?|Supplier|Company\s*Name|From)\s*[:\-\s]*([A-Za-z\s&\.]+)(?=\s*(?:Invoice|No\.?|Date|$|\d))"
+    invoice_date_pattern = r"(?:Invoice\s*Date\s*[:\-\s]*|Date\s*[:\-\s]*)(\d{4}-\d{2}-\d{2}|\d{2}/\d{2}/\d{4}|\d{2}-\d{2}-\d{4}|[A-Za-z]+\s*\d{1,2},\s*\d{4})"
+    total_amount_pattern = r"(?:Total\s*(?:Amount|Due)?\s*[:\-\s]*\$?)([\d,]+\.?\d*)"
+
+    # Invoice Number
+    invoice_num_match = re.search(invoice_num_pattern, text, re.IGNORECASE)
+    if invoice_num_match:
+        invoice_number = invoice_num_match.group(1)
+        print(f"Matched Invoice Number: {invoice_number}")  # Debug
+
+    # Vendor Name
     vendor_match = re.search(vendor_pattern, text, re.IGNORECASE)
     if vendor_match:
         vendor_name = vendor_match.group(1).strip()
+        print(f"Matched Vendor Name (Regex): {vendor_name}")  # Debug
     else:
-        # Fallback: Use NER or assume "Unknown Vendor" if not found
-        vendor_name = "Unknown Vendor"
-
-    # Extract date
-    date_pattern = r"(?:Date\s*[:\-\s]*)([0-9]{4}-[0-9]{2}-[0-9]{2})"
-    date_match = re.search(date_pattern, text, re.IGNORECASE)
-    if date_match:
-        invoice_date = datetime.strptime(date_match.group(1), "%Y-%m-%d")
-    else:
-        invoice_date = datetime.now()
-
-    # Extract total amount
-    total_amount_pattern = r"(?:Total\s*(?:Amount|before\s*tax)?\s*[:\-\s]*\$?|Total\s*\|\s*\$|Summary:\s*Total\s*before\s*tax:\s*\$)([\d,]+\.?\d*)"
-    total_match = re.search(total_amount_pattern, text, re.IGNORECASE)
-    if total_match:
-        total_amount = float(total_match.group(1).replace(",", ""))
-    else:
-        # Calculate from table if total amount not explicitly stated
-        table_pattern = r"\|.*?\|.*?\|.*?\|.*?\|"
-        tables = re.findall(table_pattern, text, re.DOTALL)
-        total_amount = 0.0
-        for table in tables:
-            lines = table.split("\n")
-            for line in lines:
-                if "Total Price" in line or line.startswith("| Item Description"):
-                    continue
-                cells = [cell.strip() for cell in line.split("|") if cell.strip()]
-                if len(cells) >= 4:
-                    try:
-                        total_price = float(cells[-1].replace("$", "").replace(",", ""))
-                        total_amount += total_price
-                    except (ValueError, IndexError):
-                        continue
-
-        # Adjust for shipping, discount, or tax if present
-        shipping_pattern = r"Shipping\s*Cost\s*[:\-\s]*\$([\d,]+\.?\d*)"
-        shipping_match = re.search(shipping_pattern, text, re.IGNORECASE)
-        if shipping_match:
-            total_amount += float(shipping_match.group(1).replace(",", ""))
-
-        discount_pattern = r"Discount\s*\(\d+%\)\s*[:\-\s]*\$([\d,]+\.?\d*)"
-        discount_match = re.search(discount_pattern, text, re.IGNORECASE)
-        if discount_match:
-            total_amount -= float(discount_match.group(1).replace(",", ""))
-
-        tax_pattern = r"Tax\s*\(\d+%\)\s*[:\-\s]*\$([\d,]+\.?\d*)"
-        tax_match = re.search(tax_pattern, text, re.IGNORECASE)
-        if tax_match:
-            total_amount += float(tax_match.group(1).replace(",", ""))
-
-    return {
-        "invoice_number": invoice_number,
-        "vendor_name": vendor_name,
-        "invoice_date": invoice_date,
-        "total_amount": total_amount,
-        "text_length": len(text)
-    }
+        # Enhanced NER fallback for multi-word organization names
+        ner_results = ner_pipeline(text)
+        org_name_parts = []
+        for i, entity in enumerate(ner_results):
+            if entity['entity'].startswith('B-ORG'):
+                org_name_parts = [entity['word']]
+            elif entity['entity'].startswith('I-ORG') and org_name_parts:
+                org_name_parts.append(entity['word'])
+        if org_name_parts:
+            vendor_name = " ".join(part.replace("##", "") for part in org_name_parts)
+            print(f"NER Matched Vendor Name: {vendor_name}")  # Debug
+
+    # Invoice Date
+    invoice_date_match = re.search(invoice_date_pattern, text, re.IGNORECASE)
+    if invoice_date_match:
+        date_str = invoice_date_match.group(1)
+        try:
+            if "/" in date_str:
+                invoice_date = datetime.strptime(date_str, "%m/%d/%Y").date()
+            elif "," in date_str:
+                invoice_date = datetime.strptime(date_str, "%B %d, %Y").date()
+            elif "-" in date_str:
+                try:
+                    invoice_date = datetime.strptime(date_str, "%Y-%m-%d").date()
+                except ValueError:
+                    invoice_date = datetime.strptime(date_str, "%d-%m-%Y").date()
+            print(f"Matched Invoice Date: {invoice_date}")  # Debug
+        except ValueError as e:
+            print(f"Failed to parse Invoice Date '{date_str}': {str(e)}")  # Debug
+
+    # Total Amount
+    total_amount_match = re.search(total_amount_pattern, text, re.IGNORECASE)
+    if total_amount_match:
+        total_amount = float(total_amount_match.group(1).replace(",", ""))
+        print(f"Matched Total Amount: {total_amount}")  # Debug
+
+    return invoice_number, vendor_name, invoice_date, total_amount
+
+def fetch_vendor_history(vendor_name, invoice_number, time_window_days=30):
+    """Fetch historical invoices for the vendor from Salesforce."""
+    if sf is None:
+        return pd.DataFrame()
+
+    try:
+        end_date = datetime.now().date()
+        start_date = end_date - timedelta(days=time_window_days)
+        
+        query = f"""
+            SELECT Invoice_Number__c, Invoice_Amount__c, Invoice_Date__c, Vendor_Name__c
+            FROM Invoice_Record__c
+            WHERE Invoice_Date__c >= {start_date} AND Invoice_Date__c <= {end_date}
+            AND Vendor_Name__c = '{vendor_name}'
+            LIMIT 100
+        """
+        result = sf.query(query)
+        records = result['records']
+        
+        history_df = pd.DataFrame(records)
+        if not history_df.empty:
+            history_df['Invoice_Date__c'] = pd.to_datetime(history_df['Invoice_Date__c']).dt.date
+        return history_df
+    except Exception as e:
+        print(f"Failed to fetch vendor history: {str(e)}")
+        return pd.DataFrame()
+
+def check_data_consistency(invoice_number, vendor_name, invoice_date, history_df):
+    """Check for data consistency issues like duplicates."""
+    consistency_issues = []
 
-# Fetch vendor history from Salesforce
-def fetch_vendor_history(sf, vendor_name, invoice_date):
-    # Simulate Salesforce query
-    # In practice, replace with actual Salesforce query
-    # Query: Select invoices for the vendor within the last 30 days
-    history = []
-    for invoice in invoice_history:  # invoice_history is a global list for this example
-        if invoice["Vendor_Name__c"] == vendor_name:
-            inv_date = datetime.strptime(invoice["Invoice_Date__c"], "%Y-%m-%d")
-            if (invoice_date - inv_date).days <= 30 and inv_date < invoice_date:
-                history.append({
-                    "Invoice_Number__c": invoice["Invoice_Number__c"],
-                    "Invoice_Amount__c": invoice["Invoice_Amount__c"],
-                    "Invoice_Date__c": inv_date
-                })
-    return pd.DataFrame(history)
-
-# Check for duplicate invoices
-def check_data_consistency(history_df, invoice_number, vendor_name):
-    issues = []
     if not history_df.empty:
-        # Check for duplicates across all vendors
-        duplicate_invoices = history_df[history_df["Invoice_Number__c"] == invoice_number]
-        # To check duplicates only within the same vendor, uncomment the following line:
-        # duplicate_invoices = history_df[(history_df["Invoice_Number__c"] == invoice_number) & (history_df["Vendor_Name__c"] == vendor_name)]
+        duplicate_invoices = history_df[history_df['Invoice_Number__c'] == invoice_number]
         if not duplicate_invoices.empty:
-            issues.append(f"Duplicate invoice number '{invoice_number}' found for vendor '{vendor_name}'.")
-    return issues
-
-# Detect anomalies
-def detect_anomalies(history_df, current_amount, current_date):
-    amount_anomaly = "No anomalies"
-    frequency_anomaly = "No anomalies"
-    vendor_pattern_anomaly = "No anomalies"
-
-    # Skip anomaly detection if fewer than 3 data points
-    if len(history_df) < 3:
-        return amount_anomaly, frequency_anomaly, vendor_pattern_anomaly, 0, 0, 0
-
-    # Amount Anomaly: Flag if current amount deviates more than 2 std from mean
-    amounts = history_df["Invoice_Amount__c"].values
-    mean_amount = np.mean(amounts)
-    std_amount = np.std(amounts)
-    amount_score = 0
-    if std_amount > 0 and (current_amount > mean_amount + 2 * std_amount or current_amount < mean_amount - 2 * std_amount):
-        amount_anomaly = "Anomaly detected"
-        amount_score = 30
-
-    # Frequency Anomaly: Flag if frequency > 1 invoice/day or date clustering < 1 day
-    dates = [d.to_pydatetime() for d in history_df["Invoice_Date__c"]]
-    days_diff = (max(dates) - min(dates)).days + 1
-    frequency = len(dates) / days_diff if days_diff > 0 else 0
-    date_clustering = np.std([(d - min(dates)).days for d in dates]) if len(dates) > 1 else 0
-    frequency_score = 0
-    if frequency > 1 or (date_clustering < 1 and date_clustering > 0):
-        frequency_anomaly = "Anomaly detected"
-        frequency_score = 25
-
-    # Vendor Pattern Anomaly: Flag if amount deviation is high and invoice count pattern is unusual
-    vendor_pattern_score = 0
-    if std_amount > 0 and (current_amount > mean_amount + 2 * std_amount or current_amount < mean_amount - 2 * std_amount):
-        vendor_pattern_anomaly = "Anomaly detected"
-        vendor_pattern_score = 25
-
-    return amount_anomaly, frequency_anomaly, vendor_pattern_anomaly, amount_score, frequency_score, vendor_pattern_score
-
-# Calculate fraud score
-def calculate_fraud_score(extracted_data, history_df, consistency_issues):
-    invoice_amount = extracted_data["total_amount"]
-    text_length = extracted_data["text_length"]
-    invoice_number = extracted_data["invoice_number"]
-    vendor_name = extracted_data["vendor_name"]
-    invoice_date = extracted_data["invoice_date"]
-
-    # Base score rules
-    fraud_score = 0
-    reasoning = []
+            consistency_issues.append(f"Duplicate invoice number '{invoice_number}' found for vendor '{vendor_name}'.")
 
-    # Rule 1: High invoice amount
-    if invoice_amount > 5000:
-        fraud_score += 40
-        reasoning.append("High invoice amount detected.")
+    return consistency_issues
 
-    # Rule 2: Low invoice amount
-    if invoice_amount < 10:
-        fraud_score += 20
-        reasoning.append("Unusually low invoice amount.")
+def detect_anomalies(df, history_df):
+    """Detect anomalies in amount, frequency, and vendor patterns."""
+    df["is_amount_anomaly"] = 0
+    df["is_frequency_anomaly"] = 0
+    df["is_vendor_pattern_anomaly"] = 0
+
+    if not df.empty:
+        scaler = StandardScaler()
+        X_scaled = scaler.fit_transform(df[["amount"]])
+        model = IsolationForest(contamination=0.05, random_state=42)
+        df["is_amount_anomaly"] = model.fit_predict(X_scaled)
+
+    if not history_df.empty:
+        history_df['Invoice_Date__c'] = pd.to_datetime(history_df['Invoice_Date__c'])
+        date_range = (history_df['Invoice_Date__c'].max() - history_df['Invoice_Date__c'].min()).days + 1
+        frequency = len(history_df) / max(date_range, 1)
+        
+        date_diffs = [(d - history_df['Invoice_Date__c'].min()).days for d in history_df['Invoice_Date__c']]
+        date_clustering = np.std(date_diffs) if len(date_diffs) > 1 else 0
+        
+        frequency_df = pd.DataFrame({
+            "frequency": [frequency],
+            "date_clustering": [date_clustering]
+        })
+        scaler = StandardScaler()
+        X_scaled = scaler.fit_transform(frequency_df[["frequency", "date_clustering"]])
+        model = IsolationForest(contamination=0.05, random_state=42)
+        df["is_frequency_anomaly"] = model.fit_predict(X_scaled)[0]
+    else:
+        df["is_frequency_anomaly"] = 1
+
+    if not history_df.empty and len(history_df) > 1:
+        historical_amounts = history_df["Invoice_Amount__c"].astype(float)
+        mean_amount = historical_amounts.mean()
+        std_amount = historical_amounts.std() if len(historical_amounts) > 1 else 1
+        amount_variance = historical_amounts.var() if len(historical_amounts) > 1 else 0
+        
+        current_amount = df["amount"].iloc[0]
+        deviation = abs(current_amount - mean_amount) / (std_amount if std_amount > 0 else 1)
+        invoice_count = len(history_df)
+        
+        vendor_pattern_df = pd.DataFrame({
+            "amount_deviation": [deviation],
+            "invoice_count": [invoice_count],
+            "amount_variance": [amount_variance]
+        })
+        scaler = StandardScaler()
+        X_scaled = scaler.fit_transform(vendor_pattern_df[["amount_deviation", "invoice_count", "amount_variance"]])
+        model = IsolationForest(contamination=0.05, random_state=42)
+        df["is_vendor_pattern_anomaly"] = model.fit_predict(X_scaled)[0]
+    else:
+        df["is_vendor_pattern_anomaly"] = 1
 
-    # Rule 3: Text length
-    if text_length < 500:
-        fraud_score += 0  # No additional score for now
+    return df
 
-    # Consistency issues
-    consistency_score = len(consistency_issues) * 15
-    fraud_score += consistency_score
-    reasoning.extend(consistency_issues)
+def calculate_fraud_score(amount, is_amount_anomaly, is_frequency_anomaly, is_vendor_pattern_anomaly, text_length, consistency_issues):
+    """Calculate fraud score based on amount, anomalies, text length, and consistency issues."""
+    score = 0.0
+    reasoning = []
 
-    # Anomaly detection
-    amount_anomaly, frequency_anomaly, vendor_pattern_anomaly, amount_score, frequency_score, vendor_pattern_score = detect_anomalies(
-        history_df, invoice_amount, invoice_date
-    )
-    fraud_score += amount_score + frequency_score + vendor_pattern_score
-    if amount_score > 0:
+    if amount > 5000:
+        score += 40
+        reasoning.append("High invoice amount detected.")
+    elif amount < 10:
+        score += 20
+        reasoning.append("Unusually low invoice amount.")
+
+    if is_amount_anomaly == -1:
+        score += 30
         reasoning.append("Amount flagged as an anomaly.")
-    if frequency_score > 0:
+    if is_frequency_anomaly == -1:
+        score += 25
         reasoning.append("Unusual invoice submission frequency or clustering detected.")
-    if vendor_pattern_score > 0:
+    if is_vendor_pattern_anomaly == -1:
+        score += 25
         reasoning.append("Unusual vendor pattern detected (amount deviation, frequency, or variance).")
 
-    # Cap the fraud score at 100
-    fraud_score = min(fraud_score, 100)
+    if text_length > 500:
+        score += 10
+        reasoning.append("Excessive text length in invoice.")
+
+    if consistency_issues:
+        score += 15 * len(consistency_issues)
+        reasoning.extend(consistency_issues)
+
+    return min(score, 100), reasoning
 
-    # Determine status
-    status = "Flagged" if fraud_score >= 50 else "Cleared"
-    flagged = fraud_score >= 50
+def process_invoice(pdf_file):
+    """Process a single invoice PDF and return structured markdown output."""
+    text = extract_text_from_pdf(pdf_file)
+    if "Error" in text:
+        return f"**Error**: {text}"
+
+    invoice_number, vendor_name, invoice_date, total_amount = extract_entities(text)
+    text_length = len(text)
 
-    if not reasoning:
-        reasoning.append("No specific fraud indicators detected")
+    history_df = fetch_vendor_history(vendor_name, invoice_number)
+    consistency_issues = check_data_consistency(invoice_number, vendor_name, invoice_date, history_df)
 
-    return {
-        "fraud_score": fraud_score,
-        "status": status,
-        "flagged": flagged,
-        "amount_anomaly": amount_anomaly,
-        "frequency_anomaly": frequency_anomaly,
-        "vendor_pattern_anomaly": vendor_pattern_anomaly,
-        "reasoning": reasoning
+    data = {
+        "invoice_id": str(uuid.uuid4()),
+        "invoice_number": invoice_number,
+        "vendor_name": vendor_name,
+        "amount": total_amount,
+        "invoice_date": invoice_date,
+        "text_length": text_length
     }
+    df = pd.DataFrame([data])
 
-# Save to Salesforce
-def save_to_salesforce(sf, extracted_data, fraud_results):
-    # Simulate saving to Salesforce
-    invoice_history.append({
-        "Invoice_Number__c": extracted_data["invoice_number"],
-        "Vendor_Name__c": extracted_data["vendor_name"],
-        "Invoice_Date__c": extracted_data["invoice_date"].strftime("%Y-%m-%d"),
-        "Invoice_Amount__c": extracted_data["total_amount"],
-        "Fraud_Score__c": fraud_results["fraud_score"],
-        "Status__c": fraud_results["status"]
-    })
-
-# Main processing function
-def process_invoice(pdf_file):
-    # Simulate OCR extraction (in practice, use an OCR library like Tesseract)
-    text = pdf_file  # For this example, the text is already provided
-
-    # Connect to Salesforce
-    sf = connect_to_salesforce()
-
-    # Extract entities
-    extracted_data = extract_entities(text)
-
-    # Fetch vendor history
-    history_df = fetch_vendor_history(sf, extracted_data["vendor_name"], extracted_data["invoice_date"])
-
-    # Check data consistency
-    consistency_issues = check_data_consistency(history_df, extracted_data["invoice_number"], extracted_data["vendor_name"])
-
-    # Calculate fraud score
-    fraud_results = calculate_fraud_score(extracted_data, history_df, consistency_issues)
-
-    # Save to Salesforce
-    save_to_salesforce(sf, extracted_data, fraud_results)
-
-    # Prepare output
-    output = f"""
-## Fraud Detection Summary
-- **Invoice Number**: {extracted_data["invoice_number"]}
-- **Vendor Name**: {extracted_data["vendor_name"]}
-- **Invoice Date**: {extracted_data["invoice_date"].strftime("%Y-%m-%d")}
-- **Invoice Amount**: ${extracted_data["total_amount"]:.2f}
-- **Fraud Score**: {fraud_results["fraud_score"]}
-- **Status**: {fraud_results["status"]}
-- **Flagged**: {fraud_results["flagged"]}
-- **Amount Anomaly**: {fraud_results["amount_anomaly"]}
-- **Frequency Anomaly**: {fraud_results["frequency_anomaly"]}
-- **Vendor Pattern Anomaly**: {fraud_results["vendor_pattern_anomaly"]}
-
-## Fraud Reasoning
-- {". ".join(fraud_results["reasoning"])}.
-"""
-    return output
-
-# Global list to simulate Salesforce database
-invoice_history = []
-
-# Gradio interface
-with gr.Blocks() as demo:
-    gr.Markdown("# Invoice Fraud Detection App")
-    pdf_input = gr.Textbox(label="Upload Invoice Text (Simulated OCR Output)", placeholder="Paste the OCR-extracted text here...")
-    output = gr.Markdown()
-    submit_btn = gr.Button("Process Invoice")
-    submit_btn.click(fn=process_invoice, inputs=pdf_input, outputs=output)
+    df = detect_anomalies(df, history_df)
+
+    fraud_score, fraud_reasoning = calculate_fraud_score(
+        df["amount"].iloc[0],
+        df["is_amount_anomaly"].iloc[0],
+        df["is_frequency_anomaly"].iloc[0],
+        df["is_vendor_pattern_anomaly"].iloc[0],
+        text_length,
+        consistency_issues
+    )
+
+    output = [
+        "## Fraud Detection Summary",
+        f"- **Invoice Number**: {invoice_number}",
+        f"- **Vendor Name**: {vendor_name}",
+        f"- **Invoice Date**: {invoice_date}",
+        f"- **Invoice Amount**: ${total_amount:,.2f}",
+        f"- **Fraud Score**: {fraud_score}",
+        f"- **Status**: {'Flagged' if fraud_score > 50 else 'Cleared'}",
+        f"- **Flagged**: {fraud_score > 50}",
+        f"- **Amount Anomaly**: {'Anomaly detected' if df['is_amount_anomaly'].iloc[0] == -1 else 'No anomalies'}",
+        f"- **Frequency Anomaly**: {'Anomaly detected' if df['is_frequency_anomaly'].iloc[0] == -1 else 'No anomalies'}",
+        f"- **Vendor Pattern Anomaly**: {'Anomaly detected' if df['is_vendor_pattern_anomaly'].iloc[0] == -1 else 'No anomalies'}",
+        "",
+        "## Fraud Reasoning"
+    ]
+
+    if fraud_reasoning:
+        output.extend([f"- {reason}" for reason in fraud_reasoning])
+    else:
+        output.append("- No specific fraud indicators detected")
+
+    if sf is not None:
+        try:
+            sf.Invoice_Record__c.create({
+                "Invoice_Number__c": invoice_number,
+                "Vendor_Name__c": vendor_name,
+                "Invoice_Amount__c": total_amount,
+                "Invoice_Date__c": str(invoice_date),
+                "Fraud_Score__c": fraud_score,
+                "Fraud_Reason__c": "; ".join(fraud_reasoning),
+                "Flagged__c": fraud_score > 50,
+                "Status__c": "Flagged" if fraud_score > 50 else "Cleared"
+            })
+        except Exception as e:
+            print(f"Failed to create Salesforce record: {str(e)}")
+            pass
+
+    return "\n".join(output)
+
+def gradio_interface(pdf_file):
+    """Gradio interface to process uploaded PDF and display structured results."""
+    if pdf_file is None:
+        return "Please upload a PDF file."
+    result = process_invoice(pdf_file)
+    return result
+
+with gr.Blocks(css=".prose a[href*='share']:has(svg) {display:none !important;}") as iface:
+    gr.Markdown("# Invoice Fraud Detection")
+    with gr.Row():
+        file_input = gr.File(label="Upload Invoice PDF")
+    result_output = gr.Markdown(label="Fraud Detection Results")
+    file_input.change(fn=gradio_interface, inputs=file_input, outputs=result_output)
 
 if __name__ == "__main__":
-    demo.launch()
+    iface.launch()