Update app.py

app.py

@@ -1,336 +1,286 @@
-import os
-from dotenv import load_dotenv
-import logging
-import pdfplumber
+import re
 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, 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)
+from simple_salesforce import Salesforce
+import warnings
+warnings.filterwarnings("ignore")
 
-# 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)}"
+# Salesforce connection (mocked for this example)
+def connect_to_salesforce():
+    return None  # Replace with actual Salesforce connection
 
+# Extract entities from OCR text
 def extract_entities(text):
-    """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
+    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]+)"
     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:
-        # 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 = []
-
-    if not history_df.empty:
-        duplicate_invoices = history_df[history_df['Invoice_Number__c'] == invoice_number]
-        if not duplicate_invoices.empty:
-            consistency_issues.append(f"Duplicate invoice number '{invoice_number}' found for vendor '{vendor_name}'.")
-
-    return consistency_issues
-
-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]
+        # 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:
-        df["is_vendor_pattern_anomaly"] = 1
+        invoice_date = datetime.now()
 
-    return df
+    # 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)
+    }
 
-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
+# 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)]
+        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 = []
 
-    if amount > 5000:
-        score += 40
+    # Rule 1: High invoice amount
+    if invoice_amount > 5000:
+        fraud_score += 40
         reasoning.append("High invoice amount detected.")
-    elif amount < 10:
-        score += 20
+
+    # Rule 2: Low invoice amount
+    if invoice_amount < 10:
+        fraud_score += 20
         reasoning.append("Unusually low invoice amount.")
 
-    if is_amount_anomaly == -1:
-        score += 30
+    # Rule 3: Text length
+    if text_length < 500:
+        fraud_score += 0  # No additional score for now
+
+    # Consistency issues
+    consistency_score = len(consistency_issues) * 15
+    fraud_score += consistency_score
+    reasoning.extend(consistency_issues)
+
+    # 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:
         reasoning.append("Amount flagged as an anomaly.")
-    if is_frequency_anomaly == -1:
-        score += 25
+    if frequency_score > 0:
         reasoning.append("Unusual invoice submission frequency or clustering detected.")
-    if is_vendor_pattern_anomaly == -1:
-        score += 25
+    if vendor_pattern_score > 0:
         reasoning.append("Unusual vendor pattern detected (amount deviation, frequency, or variance).")
 
-    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
+    # Cap the fraud score at 100
+    fraud_score = min(fraud_score, 100)
 
-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)
+    # Determine status
+    status = "Flagged" if fraud_score >= 50 else "Cleared"
+    flagged = fraud_score >= 50
 
-    history_df = fetch_vendor_history(vendor_name, invoice_number)
-    consistency_issues = check_data_consistency(invoice_number, vendor_name, invoice_date, history_df)
+    if not reasoning:
+        reasoning.append("No specific fraud indicators detected")
 
-    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
+    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
     }
-    df = pd.DataFrame([data])
 
-    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)
+# 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)
 
 if __name__ == "__main__":
-    iface.launch()
+    demo.launch()