Update app.py

app.py

@@ -1,535 +1,190 @@
-# ============================================================
-# LuxeRate AI - Hugging Face Gradio Space
-# Hotel Booking Cancellation Risk + Review Sentiment + n8n
-# ============================================================
-
-from __future__ import annotations
-
-import json
-from datetime import datetime, timezone
-from typing import Any, Dict, Tuple
-
 import gradio as gr
-import numpy as np
 import pandas as pd
+import numpy as np
+import os
 import requests
-
 from sklearn.ensemble import RandomForestClassifier
-from sklearn.model_selection import train_test_split
 from sklearn.preprocessing import LabelEncoder
+from nltk.sentiment import SentimentIntensityAnalyzer
+import nltk
 
-# -----------------------------
-# File paths
-# -----------------------------
-BOOKINGS_FILE = "bookings_small.csv"
-REVIEWS_FILE = "reviews_small.csv"
-FEATURE_IMPORTANCE_FILE = "feature_importance_small.csv"
-
-MONTHS = [
-    "January", "February", "March", "April", "May", "June",
-    "July", "August", "September", "October", "November", "December"
-]
-
-ASPECT_KEYWORDS = {
-    "service": ["service", "staff", "reception", "manager", "friendly", "rude"],
-    "cleanliness": ["clean", "dirty", "smell", "bathroom", "hygiene"],
-    "room_comfort": ["room", "bed", "comfortable", "noise", "quiet", "spacious"],
-    "location": ["location", "central", "distance", "metro", "transport"],
-    "food_breakfast": ["breakfast", "food", "restaurant", "buffet", "coffee"],
-    "value": ["price", "expensive", "cheap", "value", "worth"],
-}
-
-# -----------------------------
-# Safe sentiment setup
-# -----------------------------
-try:
-    import nltk
-    from nltk.sentiment import SentimentIntensityAnalyzer
+nltk.download("vader_lexicon")
 
-    try:
-        nltk.data.find("sentiment/vader_lexicon.zip")
-    except LookupError:
-        nltk.download("vader_lexicon", quiet=True)
-
-    SIA = SentimentIntensityAnalyzer()
-    VADER_AVAILABLE = True
-except Exception:
-    SIA = None
-    VADER_AVAILABLE = False
-
-POSITIVE_WORDS = {"great", "excellent", "amazing", "clean", "friendly", "perfect", "comfortable", "beautiful", "good", "love", "wonderful"}
-NEGATIVE_WORDS = {"bad", "dirty", "poor", "terrible", "slow", "rude", "noisy", "worst", "awful", "disappointing"}
-
-
-def sentiment_score(text: str) -> float:
-    text = str(text or "")
-    if VADER_AVAILABLE and SIA is not None:
-        return float(SIA.polarity_scores(text)["compound"])
-
-    words = [w.strip(".,!?;:()[]{}\"'").lower() for w in text.split()]
-    if not words:
-        return 0.0
-    pos = sum(w in POSITIVE_WORDS for w in words)
-    neg = sum(w in NEGATIVE_WORDS for w in words)
-    return float(np.clip((pos - neg) / max(len(words), 1) * 5, -1, 1))
-
-
-def sentiment_label(score: float) -> str:
-    if score >= 0.2:
-        return "Positive"
-    if score <= -0.2:
-        return "Negative"
-    return "Neutral"
-
-
-def detect_aspects(text: str) -> pd.DataFrame:
-    lower = str(text or "").lower()
-    rows = []
-    for aspect, words in ASPECT_KEYWORDS.items():
-        count = sum(1 for word in words if word in lower)
-        rows.append({"Aspect": aspect.replace("_", " ").title(), "Mentions": count})
-    return pd.DataFrame(rows)
-
-# -----------------------------
-# Data and model loading
-# -----------------------------
-
-def safe_read_csv(path: str) -> pd.DataFrame:
-    try:
-        return pd.read_csv(path)
-    except Exception:
-        return pd.DataFrame()
-
-
-bookings_df = safe_read_csv(BOOKINGS_FILE)
-reviews_df = safe_read_csv(REVIEWS_FILE)
-feature_importance_df = safe_read_csv(FEATURE_IMPORTANCE_FILE)
-
-warnings = []
-if bookings_df.empty:
-    warnings.append(f"Could not load {BOOKINGS_FILE}. Booking predictor will use fallback rules.")
-if reviews_df.empty:
-    warnings.append(f"Could not load {REVIEWS_FILE}. Review benchmarks will be unavailable.")
-if feature_importance_df.empty:
-    warnings.append(f"Could not load {FEATURE_IMPORTANCE_FILE}. Feature importance table will be unavailable.")
-
-MODEL_FEATURES = [
-    "hotel", "lead_time", "arrival_date_month",
-    "stays_in_weekend_nights", "stays_in_week_nights",
-    "adults", "children", "babies",
-    "meal", "market_segment", "distribution_channel",
-    "is_repeated_guest", "previous_cancellations",
-    "previous_bookings_not_canceled",
-    "reserved_room_type", "deposit_type", "customer_type",
-    "adr", "required_car_parking_spaces",
-    "total_of_special_requests",
-    "total_nights", "total_guests", "is_family",
-    "seasonality_index", "competitor_price_index",
-    "service_quality_proxy", "booking_value_score",
-]
-
-model = None
-encoders: Dict[str, LabelEncoder] = {}
-model_features_used = []
-default_values: Dict[str, Any] = {}
-
-
-def build_model() -> None:
-    global model, encoders, model_features_used, default_values
-    if bookings_df.empty or "is_canceled" not in bookings_df.columns:
-        return
-
-    df = bookings_df.copy()
-    model_features_used = [c for c in MODEL_FEATURES if c in df.columns]
-    if not model_features_used:
-        return
-
-    X = df[model_features_used].copy()
-    y = df["is_canceled"].astype(int)
+# =========================
+# LOAD DATA
+# =========================
+bookings = pd.read_csv("bookings_small.csv")
+reviews = pd.read_csv("reviews_small.csv")
+feature_importance = pd.read_csv("feature_importance_small.csv")
 
-    for col in X.columns:
-        if X[col].dtype == "object":
-            X[col] = X[col].fillna("Unknown").astype(str)
-            le = LabelEncoder()
-            X[col] = le.fit_transform(X[col])
-            encoders[col] = le
-            default_values[col] = str(df[col].mode().iloc[0]) if not df[col].mode().empty else "Unknown"
-        else:
-            X[col] = pd.to_numeric(X[col], errors="coerce")
-            default_values[col] = float(X[col].median()) if not X[col].dropna().empty else 0.0
-            X[col] = X[col].fillna(default_values[col])
+# =========================
+# TRAIN MODEL
+# =========================
+X = bookings.drop(columns=["is_canceled"])
+y = bookings["is_canceled"]
 
-    try:
-        X_train, _, y_train, _ = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)
-    except Exception:
-        X_train, y_train = X, y
-
-    model = RandomForestClassifier(
-        n_estimators=120,
-        max_depth=10,
-        min_samples_split=8,
-        min_samples_leaf=4,
-        random_state=42,
-        n_jobs=-1,
-    )
-    model.fit(X_train, y_train)
-
-
-build_model()
-
-# -----------------------------
-# UI helper functions
-# -----------------------------
-
-def choices_for(col: str, fallback: list[str]) -> list[str]:
-    if not bookings_df.empty and col in bookings_df.columns:
-        vals = sorted([str(v) for v in bookings_df[col].dropna().unique().tolist()])
-        return vals if vals else fallback
-    return fallback
-
-
-def compute_engineered_features(
-    hotel: str,
-    arrival_date_month: str,
-    stays_in_weekend_nights: float,
-    stays_in_week_nights: float,
-    adults: float,
-    children: float,
-    babies: float,
-    is_repeated_guest: bool,
-    previous_cancellations: float,
-    total_of_special_requests: float,
-    adr: float,
-) -> Dict[str, float]:
-    total_nights = float(stays_in_weekend_nights or 0) + float(stays_in_week_nights or 0)
-    total_guests = float(adults or 0) + float(children or 0) + float(babies or 0)
-    is_family = 1 if total_guests > 2 else 0
-
-    month_num = MONTHS.index(arrival_date_month) + 1 if arrival_date_month in MONTHS else 1
-    if month_num in [6, 7, 8, 12]:
-        seasonality_index = 1.20
-    elif month_num in [4, 5, 9, 10]:
-        seasonality_index = 1.00
-    else:
-        seasonality_index = 0.85
+encoders = {}
+for col in X.select_dtypes(include="object").columns:
+    le = LabelEncoder()
+    X[col] = le.fit_transform(X[col].astype(str))
+    encoders[col] = le
 
-    competitor_price_index = (1.05 if hotel == "City Hotel" else 0.95) * seasonality_index
-    repeated = 1 if is_repeated_guest else 0
-    service_quality_proxy = 50 + 5 * float(total_of_special_requests or 0) + 8 * repeated - 3 * float(previous_cancellations or 0)
-    service_quality_proxy = float(np.clip(service_quality_proxy, 0, 100))
-    booking_value_score = float(adr or 0) * total_nights * max(total_guests, 1)
+model = RandomForestClassifier(n_estimators=100, max_depth=10)
+model.fit(X, y)
 
-    return {
-        "total_nights": total_nights,
-        "total_guests": total_guests,
-        "is_family": is_family,
-        "seasonality_index": seasonality_index,
-        "competitor_price_index": competitor_price_index,
-        "service_quality_proxy": service_quality_proxy,
-        "booking_value_score": booking_value_score,
-    }
+sia = SentimentIntensityAnalyzer()
 
+WEBHOOK_URL = os.getenv("N8N_WEBHOOK_URL")
 
-def encode_input_row(row: Dict[str, Any]) -> pd.DataFrame:
-    model_row = {}
-    for col in model_features_used:
-        value = row.get(col, default_values.get(col, 0))
-        if col in encoders:
-            value = str(value)
-            le = encoders[col]
-            if value not in le.classes_:
-                value = default_values.get(col, le.classes_[0])
-                if value not in le.classes_:
-                    value = le.classes_[0]
-            model_row[col] = int(le.transform([value])[0])
-        else:
-            try:
-                model_row[col] = float(value)
-            except Exception:
-                model_row[col] = float(default_values.get(col, 0.0))
-    return pd.DataFrame([model_row], columns=model_features_used)
-
-
-def risk_label(probability: float) -> str:
-    if probability < 0.30:
-        return "Low"
-    if probability <= 0.60:
-        return "Medium"
-    return "High"
-
-
-def pricing_recommendation(risk: str, review_sentiment: str | None = None) -> str:
-    if risk == "High":
-        return "Reduce or hold pricing"
-    if risk == "Medium":
-        return "Hold pricing and monitor"
-    if review_sentiment == "Negative":
-        return "Hold pricing until service issues improve"
-    return "Premium pricing may be justified"
-
-
-def predict_booking(
-    hotel, lead_time, arrival_date_month, stays_in_weekend_nights, stays_in_week_nights,
-    adults, children, babies, meal, market_segment, distribution_channel,
-    is_repeated_guest, previous_cancellations, previous_bookings_not_canceled,
-    reserved_room_type, deposit_type, customer_type, adr,
-    required_car_parking_spaces, total_of_special_requests, latest_state
-):
-    engineered = compute_engineered_features(
-        hotel, arrival_date_month, stays_in_weekend_nights, stays_in_week_nights,
-        adults, children, babies, is_repeated_guest, previous_cancellations,
-        total_of_special_requests, adr
-    )
-
-    input_row = {
+# =========================
+# BOOKING PREDICTOR
+# =========================
+def predict_booking(hotel, lead_time, adr, total_nights, total_guests,
+                    market_segment, deposit_type, is_repeated_guest,
+                    previous_cancellations, total_of_special_requests):
+
+    input_dict = {
         "hotel": hotel,
         "lead_time": lead_time,
-        "arrival_date_month": arrival_date_month,
-        "stays_in_weekend_nights": stays_in_weekend_nights,
-        "stays_in_week_nights": stays_in_week_nights,
-        "adults": adults,
-        "children": children,
-        "babies": babies,
-        "meal": meal,
+        "adr": adr,
+        "total_nights": total_nights,
+        "total_guests": total_guests,
         "market_segment": market_segment,
-        "distribution_channel": distribution_channel,
-        "is_repeated_guest": 1 if is_repeated_guest else 0,
-        "previous_cancellations": previous_cancellations,
-        "previous_bookings_not_canceled": previous_bookings_not_canceled,
-        "reserved_room_type": reserved_room_type,
         "deposit_type": deposit_type,
-        "customer_type": customer_type,
-        "adr": adr,
-        "required_car_parking_spaces": required_car_parking_spaces,
+        "is_repeated_guest": is_repeated_guest,
+        "previous_cancellations": previous_cancellations,
         "total_of_special_requests": total_of_special_requests,
-        **engineered,
+        "seasonality_index": 1.0,
+        "competitor_price_index": 1.0,
+        "service_quality_proxy": 50,
+        "booking_value_score": adr * total_nights * max(total_guests,1)
     }
 
-    if model is not None and model_features_used:
-        encoded = encode_input_row(input_row)
-        prob = float(model.predict_proba(encoded)[0][1])
-    else:
-        # Fallback business-rule estimate if model cannot train
-        prob = 0.25
-        prob += min(float(lead_time or 0) / 365, 0.30)
-        prob += 0.20 if str(deposit_type).lower() != "no deposit" else 0
-        prob += 0.10 if float(previous_cancellations or 0) > 0 else 0
-        prob -= 0.08 if is_repeated_guest else 0
-        prob -= 0.03 * float(total_of_special_requests or 0)
-        prob = float(np.clip(prob, 0.01, 0.95))
-
-    risk = risk_label(prob)
-    rec = pricing_recommendation(risk)
-    explanation = (
-        f"Cancellation probability is estimated at {prob:.1%}. "
-        f"The booking is classified as {risk} risk. "
-        f"Recommendation: {rec}."
-    )
-
-    top_features = feature_importance_df.head(5) if not feature_importance_df.empty else pd.DataFrame({"feature": [], "importance": []})
-
-    result_md = f"""
-### Booking Risk Result
-
-**Cancellation probability:** {prob:.1%}  
-**Risk label:** {risk}  
-**Pricing recommendation:** {rec}  
-
-**Business explanation:** {explanation}
-"""
+    df_input = pd.DataFrame([input_dict])
 
-    payload = {
-        "source_tab": "booking_risk",
-        "timestamp": datetime.now(timezone.utc).isoformat(),
-        "inputs": input_row,
-        "outputs": {
-            "cancellation_probability": round(prob, 4),
-            "risk_label": risk,
-            "pricing_recommendation": rec,
-            "business_summary": explanation,
-        },
-    }
-    return result_md, top_features, payload, json.dumps(payload, indent=2)
+    for col, le in encoders.items():
+        if col in df_input:
+            df_input[col] = le.transform(df_input[col].astype(str))
 
+    for col in X.columns:
+        if col not in df_input:
+            df_input[col] = 0
 
-def analyze_review(review_text: str, latest_state):
-    score = sentiment_score(review_text)
-    label = sentiment_label(score)
-    aspects = detect_aspects(review_text)
+    df_input = df_input[X.columns]
 
-    if label == "Negative":
-        rec = "Investigate operational issues before increasing price."
-    elif label == "Positive":
-        rec = "Service perception supports premium positioning."
-    else:
-        rec = "Maintain service standards and monitor feedback."
+    prob = model.predict_proba(df_input)[0][1]
 
-    if not reviews_df.empty and "sentiment_label" in reviews_df.columns:
-        dist = (reviews_df["sentiment_label"].value_counts(normalize=True) * 100).round(1).to_dict()
-        benchmark = ", ".join([f"{k}: {v}%" for k, v in dist.items()])
+    if prob > 0.6:
+        risk = "High"
+        rec = "Reduce pricing / investigate risk"
+    elif prob > 0.3:
+        risk = "Medium"
+        rec = "Monitor closely"
     else:
-        benchmark = "Benchmark unavailable."
-
-    result_md = f"""
-### Review Sentiment Result
-
-**Sentiment score:** {score:.3f}  
-**Sentiment label:** {label}  
-**Management recommendation:** {rec}  
-
-**Benchmark distribution from dataset:** {benchmark}
-"""
-
-    payload = {
-        "source_tab": "review_sentiment",
-        "timestamp": datetime.now(timezone.utc).isoformat(),
-        "inputs": {"review_text": str(review_text or "")[:1000]},
-        "outputs": {
-            "sentiment_score": round(score, 4),
-            "sentiment_label": label,
-            "aspect_mentions": aspects.to_dict(orient="records"),
-            "business_summary": rec,
-        },
-    }
-    return result_md, aspects, payload, json.dumps(payload, indent=2)
-
-
-def send_to_n8n(webhook_url: str, latest_payload: Dict[str, Any] | None):
-    if not webhook_url or not str(webhook_url).startswith("http"):
-        return "Please enter a valid n8n webhook URL.", "{}"
-    if not latest_payload:
-        return "No analysis has been generated yet. Run the booking predictor or review analyzer first.", "{}"
+        risk = "Low"
+        rec = "Safe to increase pricing"
+
+    return prob, risk, rec, input_dict
+
+# =========================
+# SENTIMENT
+# =========================
+def analyze_review(text):
+    score = sia.polarity_scores(text)["compound"]
+    if score > 0.2:
+        label = "Positive"
+    elif score < -0.2:
+        label = "Negative"
+    else:
+        label = "Neutral"
+    return score, label
 
-    payload = dict(latest_payload)
-    payload["sent_from"] = "LuxeRate AI Hugging Face Space"
+# =========================
+# SEND TO N8N
+# =========================
+def send_to_n8n(source_tab, payload):
+    if not WEBHOOK_URL:
+        return "❌ Missing webhook secret"
 
     try:
-        response = requests.post(webhook_url, json=payload, timeout=20)
-        if 200 <= response.status_code < 300:
-            return f"Success: payload sent to n8n. Status code: {response.status_code}", json.dumps(payload, indent=2)
-        return f"n8n returned an error. Status code: {response.status_code}. Response: {response.text[:500]}", json.dumps(payload, indent=2)
-    except Exception as e:
-        return f"Could not reach n8n webhook: {e}", json.dumps(payload, indent=2)
+        response = requests.post(WEBHOOK_URL, json={
+            "source_tab": source_tab,
+            "inputs": payload
+        }, timeout=10)
 
-# -----------------------------
-# Gradio App
-# -----------------------------
+        if response.status_code == 200:
+            data = response.json()
+            return f"""
+✅ SUCCESS
 
-custom_css = """
-.gradio-container {max-width: 1180px !important; margin: auto !important;}
-.metric-card {padding: 16px; border-radius: 14px; border: 1px solid #e5e7eb; background: #fafafa;}
-"""
+Message: {data.get("message")}
 
-with gr.Blocks(title="LuxeRate AI", css=custom_css) as demo:
-    latest_payload_state = gr.State({})
+Decision: {data.get("decision")}
 
-    gr.Markdown(
-        """
-# LuxeRate AI
-### AI-powered hotel cancellation risk, review sentiment, and n8n workflow automation
+Severity: {data.get("severity")}
 
-This app uses the reduced project datasets: `bookings_small.csv`, `reviews_small.csv`, and `feature_importance_small.csv`.
-It sends only lightweight result payloads to n8n to avoid 502 errors.
+Recommendation: {data.get("recommendation")}
 """
-    )
-
-    if warnings:
-        gr.Warning(" | ".join(warnings))
-
-    with gr.Tab("1. Booking Risk Predictor"):
-        gr.Markdown("### Predict cancellation risk and generate a pricing action")
-        with gr.Row():
-            with gr.Column():
-                hotel = gr.Dropdown(choices_for("hotel", ["City Hotel", "Resort Hotel"]), value="City Hotel", label="Hotel type")
-                lead_time = gr.Number(value=45, label="Lead time")
-                arrival_date_month = gr.Dropdown(MONTHS, value="July", label="Arrival month")
-                stays_in_weekend_nights = gr.Number(value=1, label="Weekend nights")
-                stays_in_week_nights = gr.Number(value=2, label="Week nights")
-                adults = gr.Number(value=2, label="Adults")
-                children = gr.Number(value=0, label="Children")
-                babies = gr.Number(value=0, label="Babies")
-                adr = gr.Number(value=150, label="Average Daily Rate / ADR")
-            with gr.Column():
-                meal = gr.Dropdown(choices_for("meal", ["BB", "HB", "SC", "Undefined"]), value=choices_for("meal", ["BB"])[0], label="Meal")
-                market_segment = gr.Dropdown(choices_for("market_segment", ["Online TA", "Direct", "Groups"]), value=choices_for("market_segment", ["Online TA"])[0], label="Market segment")
-                distribution_channel = gr.Dropdown(choices_for("distribution_channel", ["TA/TO", "Direct"]), value=choices_for("distribution_channel", ["TA/TO"])[0], label="Distribution channel")
-                reserved_room_type = gr.Dropdown(choices_for("reserved_room_type", ["A", "D", "E"]), value=choices_for("reserved_room_type", ["A"])[0], label="Reserved room type")
-                deposit_type = gr.Dropdown(choices_for("deposit_type", ["No Deposit", "Non Refund", "Refundable"]), value=choices_for("deposit_type", ["No Deposit"])[0], label="Deposit type")
-                customer_type = gr.Dropdown(choices_for("customer_type", ["Transient", "Contract", "Group"]), value=choices_for("customer_type", ["Transient"])[0], label="Customer type")
-                is_repeated_guest = gr.Checkbox(value=False, label="Repeated guest")
-                previous_cancellations = gr.Number(value=0, label="Previous cancellations")
-                previous_bookings_not_canceled = gr.Number(value=0, label="Previous bookings not canceled")
-                required_car_parking_spaces = gr.Number(value=0, label="Required car parking spaces")
-                total_of_special_requests = gr.Number(value=1, label="Special requests")
-
-        predict_btn = gr.Button("Predict booking risk", variant="primary")
-        booking_result = gr.Markdown()
-        feature_table = gr.Dataframe(label="Top 5 model drivers", interactive=False)
-        booking_payload_preview = gr.Code(label="Latest payload preview", language="json")
-
-        predict_btn.click(
-            predict_booking,
-            inputs=[
-                hotel, lead_time, arrival_date_month, stays_in_weekend_nights, stays_in_week_nights,
-                adults, children, babies, meal, market_segment, distribution_channel,
-                is_repeated_guest, previous_cancellations, previous_bookings_not_canceled,
-                reserved_room_type, deposit_type, customer_type, adr,
-                required_car_parking_spaces, total_of_special_requests, latest_payload_state,
-            ],
-            outputs=[booking_result, feature_table, latest_payload_state, booking_payload_preview],
-        )
-
-    with gr.Tab("2. Review Sentiment Analyzer"):
-        gr.Markdown("### Analyze a customer review and identify service perception issues")
-        review_text = gr.Textbox(
-            label="Paste hotel review",
-            lines=7,
-            value="The hotel location was excellent and the staff were friendly, but the room was noisy and the bathroom was not very clean.",
-        )
-        analyze_btn = gr.Button("Analyze review", variant="primary")
-        review_result = gr.Markdown()
-        aspect_table = gr.Dataframe(label="Aspect mentions", interactive=False)
-        review_payload_preview = gr.Code(label="Latest payload preview", language="json")
-
-        analyze_btn.click(
-            analyze_review,
-            inputs=[review_text, latest_payload_state],
-            outputs=[review_result, aspect_table, latest_payload_state, review_payload_preview],
-        )
-
-    with gr.Tab("3. n8n Automation"):
-        gr.Markdown(
-            """
-### Send latest analysis to n8n
-
-Create an n8n workflow with a **Webhook** trigger and paste the webhook URL below.  
-The app sends only the latest analysis result, not the full dataset, which avoids 502 errors.
-"""
-        )
-        webhook_url = gr.Textbox(label="n8n webhook URL", placeholder="https://your-n8n-domain/webhook/...")
-        send_btn = gr.Button("Send latest analysis to n8n", variant="primary")
-        n8n_status = gr.Markdown()
-        n8n_payload_preview = gr.Code(label="Payload sent to n8n", language="json")
-
-        gr.Markdown(
-            """
-#### Minimal n8n workflow
-1. Webhook node  
-2. Set node, optional  
-3. Respond to Webhook node  
-
-Suggested response body:
-```json
-{"status":"success","message":"LuxeRate AI payload received"}
-```
-"""
-        )
-
-        send_btn.click(
-            send_to_n8n,
-            inputs=[webhook_url, latest_payload_state],
-            outputs=[n8n_status, n8n_payload_preview],
-        )
+        else:
+            return f"❌ Error {response.status_code}: {response.text}"
 
-if __name__ == "__main__":
-    demo.launch()
+    except Exception as e:
+        return f"❌ Failed: {str(e)}"
+
+# =========================
+# UI
+# =========================
+with gr.Blocks() as demo:
+    gr.Markdown("# LuxeRate AI")
+
+    with gr.Tab("Booking Risk"):
+        hotel = gr.Dropdown(["City Hotel","Resort Hotel"])
+        lead_time = gr.Number()
+        adr = gr.Number()
+        total_nights = gr.Number()
+        total_guests = gr.Number()
+        market_segment = gr.Textbox()
+        deposit_type = gr.Textbox()
+        is_repeated_guest = gr.Number()
+        previous_cancellations = gr.Number()
+        total_of_special_requests = gr.Number()
+
+        output = gr.Textbox()
+        state_payload = gr.State()
+
+        def run_booking(*args):
+            prob, risk, rec, payload = predict_booking(*args)
+            return f"Prob: {prob:.2f} | Risk: {risk} | {rec}", payload
+
+        btn = gr.Button("Predict")
+        btn.click(run_booking, 
+                  [hotel, lead_time, adr, total_nights, total_guests,
+                   market_segment, deposit_type, is_repeated_guest,
+                   previous_cancellations, total_of_special_requests],
+                  [output, state_payload])
+
+        send_btn = gr.Button("Send to n8n")
+        send_output = gr.Textbox()
+
+        send_btn.click(lambda p: send_to_n8n("booking", p), 
+                       state_payload, send_output)
+
+    with gr.Tab("Review Sentiment"):
+        review = gr.Textbox()
+        sentiment_output = gr.Textbox()
+        state_review = gr.State()
+
+        def run_sentiment(text):
+            score, label = analyze_review(text)
+            return f"{score:.2f} ({label})", {"sentiment": score, "label": label}
+
+        btn2 = gr.Button("Analyze")
+        btn2.click(run_sentiment, review, [sentiment_output, state_review])
+
+        send_btn2 = gr.Button("Send to n8n")
+        send_output2 = gr.Textbox()
+
+        send_btn2.click(lambda p: send_to_n8n("review", p), 
+                        state_review, send_output2)
+
+demo.launch()