Update: Integrate Mistral-7B-Instruct-v0.2 model for NLP-to-SQL engine and add database functions

app.py

@@ -8,6 +8,7 @@ import pandas as pd
 import gradio as gr
 
 from detector import detect_plate
+
 from database import (
     save_detection,
     run_query,
@@ -18,15 +19,28 @@ from database import (
     get_suspicious_vehicles
 )
 
-asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())
+# =========================================================
+# ASYNC FIX
+# =========================================================
 
+asyncio.set_event_loop_policy(
+    asyncio.DefaultEventLoopPolicy()
+)
 
-# ================= DETECTION ================= #
+# =========================================================
+# DETECTION
+# =========================================================
 
 def detect_and_save(image):
 
     if image is None:
-        return "No image uploaded", {}
+
+        return (
+            "❌ No image uploaded",
+            {
+                "error": "No image uploaded"
+            }
+        )
 
     now = datetime.now()
 
@@ -38,6 +52,7 @@ def detect_and_save(image):
         plate, state, vehicle_type, vehicle_conf, success = detect_plate(image)
 
         if success and plate:
+
             save_detection(
                 plate,
                 state,
@@ -47,7 +62,20 @@ def detect_and_save(image):
                 time
             )
 
-        result_text = f"{date} {time} | {vehicle_type} | {plate}"
+        result_text = f"""
+✅ Detection Success
+
+📅 Date: {date}
+⏰ Time: {time}
+
+🚗 Vehicle Type: {vehicle_type}
+🔢 Plate Number: {plate}
+🌍 State: {state}
+
+🎯 Confidence: {round(vehicle_conf, 3)}
+
+💾 Saved to Database: {success}
+"""
 
         result_json = {
             "date": date,
@@ -63,73 +91,208 @@ def detect_and_save(image):
 
     except Exception as e:
 
-        return f"Error: {str(e)}", {
-            "error": str(e)
-        }
+        return (
+            f"❌ Error: {str(e)}",
+            {
+                "error": str(e)
+            }
+        )
 
 
-# ================= QUERY ================= #
+# =========================================================
+# QUERY DATABASE
+# =========================================================
 
 def query_database(user_query):
 
     if not user_query.strip():
-        return "", pd.DataFrame(), {
-            "error": "Please enter a query"
-        }
 
-    response = run_query(user_query)
+        return (
+            "",
+            pd.DataFrame(),
+            {
+                "error": "Please enter a query"
+            }
+        )
 
-    sql = response.get("sql", "")
+    try:
 
-    results = response.get("result", [])
+        response = run_query(user_query)
 
-    # Convert JSON list -> DataFrame for proper table display
-    if results:
-        df = pd.DataFrame(results)
-    else:
-        df = pd.DataFrame()
+        sql = response.get("sql", "")
+
+        results = response.get("result", [])
+
+        if results and len(results) > 0:
+
+            df = pd.DataFrame(results)
+
+        else:
+
+            df = pd.DataFrame({
+                "message": [
+                    "No matching records found"
+                ]
+            })
+
+        return (
+            sql,
+            df,
+            response
+        )
+
+    except Exception as e:
+
+        return (
+            "",
+            pd.DataFrame(),
+            {
+                "error": str(e)
+            }
+        )
+
+
+# =========================================================
+# CHATBOT
+# =========================================================
+
+def chatbot_query(message, history):
+
+    try:
+
+        response = run_query(message)
+
+        sql = response.get("sql", "")
+
+        results = response.get("result", [])
+
+        count = response.get("count", 0)
+
+        if len(results) > 5:
+            preview = results[:5]
+        else:
+            preview = results
+
+        bot_reply = f"""
+🔍 SQL Generated:
+
+{sql}
+
+📊 Results Found: {count}
+
+📁 Preview:
+
+{preview}
+"""
+
+        history.append(
+            (message, bot_reply)
+        )
+
+        return history, ""
+
+    except Exception as e:
+
+        history.append(
+            (
+                message,
+                f"❌ Error: {str(e)}"
+            )
+        )
 
-    return sql, df, response
+        return history, ""
 
 
-# ================= ANALYTICS ================= #
+# =========================================================
+# ANALYTICS
+# =========================================================
 
 def refresh_analytics():
 
-    state_data = get_vehicles_by_state()
+    try:
+
+        state_data = pd.DataFrame(
+            get_vehicles_by_state()
+        )
+
+        hourly_data = pd.DataFrame(
+            get_hourly_traffic()
+        )
+
+        top_data = pd.DataFrame(
+            get_top_plates()
+        )
+
+        suspicious_data = pd.DataFrame(
+            get_suspicious_vehicles()
+        )
+
+        return (
+            state_data,
+            hourly_data,
+            top_data,
+            suspicious_data
+        )
+
+    except Exception as e:
+
+        err_df = pd.DataFrame({
+            "error": [str(e)]
+        })
 
-    hourly_data = get_hourly_traffic()
+        return (
+            err_df,
+            err_df,
+            err_df,
+            err_df
+        )
 
-    top_data = get_top_plates()
 
-    suspicious_data = get_suspicious_vehicles()
+# =========================================================
+# HEALTH CHECK
+# =========================================================
 
-    return (
-        state_data,
-        hourly_data,
-        top_data,
-        suspicious_data
-    )
+status, msg = health_check()
 
 
-# ================= UI ================= #
+# =========================================================
+# UI
+# =========================================================
 
-with gr.Blocks(title="Vehicle Intelligence System") as demo:
+with gr.Blocks(
+    title="Vehicle Intelligence System",
+    theme=gr.themes.Soft()
+) as demo:
 
-    gr.Markdown("# 🚗 Vehicle Intelligence System")
+    # =====================================================
+    # HEADER
+    # =====================================================
 
-    gr.Markdown(
-        "AI-powered vehicle detection and intelligence system"
-    )
+    gr.Markdown("""
+# 🚗 Vehicle Intelligence System
 
-    status, msg = health_check()
+AI-powered Vehicle Detection + NLP-to-SQL Intelligence Platform
+""")
 
-    gr.Markdown(f"### {msg}")
+    if status:
+        gr.Success(msg)
+    else:
+        gr.Warning(msg)
 
-    # ================= TAB 1 ================= #
+    # =====================================================
+    # TAB 1 - DETECTION
+    # =====================================================
 
     with gr.Tab("🎥 Detection"):
 
+        gr.Markdown("""
+Upload a vehicle image for:
+
+- License Plate Detection
+- Vehicle Type Classification
+- Database Logging
+""")
+
         with gr.Row():
 
             with gr.Column():
@@ -148,7 +311,8 @@ with gr.Blocks(title="Vehicle Intelligence System") as demo:
             with gr.Column():
 
                 output_text = gr.Textbox(
-                    label="Detection Result"
+                    label="Detection Result",
+                    lines=12
                 )
 
                 output_json = gr.JSON(
@@ -161,42 +325,56 @@ with gr.Blocks(title="Vehicle Intelligence System") as demo:
             outputs=[
                 output_text,
                 output_json
-            ]
-        )
-
-    # ================= TAB 2 ================= #
-
-    with gr.Tab("🔍 Database Query"):
-
-        gr.Markdown(
-            "Ask questions about vehicles using natural language"
+            ],
+            show_progress=True
         )
 
-        with gr.Row():
+    # =====================================================
+    # TAB 2 - NLP QUERY
+    # =====================================================
 
-            ex1 = gr.Button("How many cars today?")
-            ex2 = gr.Button("Show TN vehicles")
-            ex3 = gr.Button("Top repeated plates")
-            ex4 = gr.Button("Hourly traffic")
+    with gr.Tab("🔍 NLP Database Query"):
 
-        with gr.Row():
+        gr.Markdown("""
+Ask questions using natural language.
 
-            ex5 = gr.Button("Count by vehicle type")
-            ex6 = gr.Button("Latest detections")
-            ex7 = gr.Button("Suspicious vehicles")
-            ex8 = gr.Button("State distribution")
+Examples:
+- Show TN vehicles
+- Track TN63MB3157
+- Show traffic in Adyar
+- Top repeated plates
+- Hourly traffic
+""")
 
         query_input = gr.Textbox(
-            label="Ask a question",
-            placeholder="Show all TN vehicles",
+            label="Ask a Question",
+            placeholder="Example: Show all TN vehicles",
             lines=2
         )
 
         search_btn = gr.Button(
-            "🔍 Search",
+            "🔍 Search Database",
             variant="primary"
         )
 
+        gr.Examples(
+            examples=[
+                ["Show TN vehicles"],
+                ["Track TN63MB3157"],
+                ["Show all vehicles from Adyar"],
+                ["Top repeated plates"],
+                ["Hourly traffic"],
+                ["Show suspicious vehicles"],
+                ["Show vehicle type distribution"],
+                ["Show latest detections"],
+                ["Count vehicles in Guindy"],
+                ["Show KA state vehicles"],
+                ["Show buses"],
+                ["Show traffic on 2026-05-01"]
+            ],
+            inputs=query_input
+        )
+
         with gr.Row():
 
             sql_output = gr.Code(
@@ -204,9 +382,13 @@ with gr.Blocks(title="Vehicle Intelligence System") as demo:
                 language="sql"
             )
 
-            results_output = gr.Dataframe(
-                label="Results"
-            )
+        results_output = gr.Dataframe(
+            headers=None,
+            datatype="str",
+            interactive=False,
+            wrap=True,
+            label="Results"
+        )
 
         json_output = gr.JSON(
             label="Full Response"
@@ -219,52 +401,52 @@ with gr.Blocks(title="Vehicle Intelligence System") as demo:
                 sql_output,
                 results_output,
                 json_output
-            ]
+            ],
+            show_progress=True
         )
 
-        ex1.click(
-            lambda: "How many cars today?",
-            outputs=query_input
-        )
+    # =====================================================
+    # TAB 3 - CHATBOT
+    # =====================================================
 
-        ex2.click(
-            lambda: "Show TN vehicles",
-            outputs=query_input
-        )
+    with gr.Tab("🤖 AI Assistant"):
 
-        ex3.click(
-            lambda: "Top repeated plates",
-            outputs=query_input
-        )
+        gr.Markdown("""
+Chat with the Vehicle Intelligence Database
+""")
 
-        ex4.click(
-            lambda: "Hourly traffic",
-            outputs=query_input
+        chatbot = gr.Chatbot(
+            height=500
         )
 
-        ex5.click(
-            lambda: "Count by vehicle type",
-            outputs=query_input
+        msg_box = gr.Textbox(
+            placeholder="Ask something..."
         )
 
-        ex6.click(
-            lambda: "Latest detections",
-            outputs=query_input
-        )
+        clear_btn = gr.Button("🗑 Clear Chat")
 
-        ex7.click(
-            lambda: "Suspicious vehicles",
-            outputs=query_input
+        msg_box.submit(
+            chatbot_query,
+            [msg_box, chatbot],
+            [chatbot, msg_box]
         )
 
-        ex8.click(
-            lambda: "State distribution",
-            outputs=query_input
+        clear_btn.click(
+            lambda: None,
+            None,
+            chatbot,
+            queue=False
         )
 
-    # ================= TAB 3 ================= #
+    # =====================================================
+    # TAB 4 - ANALYTICS
+    # =====================================================
+
+    with gr.Tab("📊 Analytics Dashboard"):
 
-    with gr.Tab("📊 Analytics"):
+        gr.Markdown("""
+Real-time traffic analytics from vehicle intelligence database
+""")
 
         refresh_btn = gr.Button(
             "🔄 Refresh Analytics",
@@ -274,21 +456,25 @@ with gr.Blocks(title="Vehicle Intelligence System") as demo:
         with gr.Row():
 
             state_table = gr.Dataframe(
-                label="Vehicles By State"
+                label="🚘 Vehicles By State",
+                interactive=False
             )
 
             hourly_table = gr.Dataframe(
-                label="Traffic By Hour"
+                label="🕒 Traffic By Hour",
+                interactive=False
             )
 
         with gr.Row():
 
             top_table = gr.Dataframe(
-                label="Top Plates"
+                label="🏆 Top Repeated Plates",
+                interactive=False
             )
 
             suspicious_table = gr.Dataframe(
-                label="Suspicious Vehicles"
+                label="⚠ Suspicious Vehicles",
+                interactive=False
             )
 
         refresh_btn.click(
@@ -301,8 +487,42 @@ with gr.Blocks(title="Vehicle Intelligence System") as demo:
             ]
         )
 
+        demo.load(
+            fn=refresh_analytics,
+            outputs=[
+                state_table,
+                hourly_table,
+                top_table,
+                suspicious_table
+            ]
+        )
+
+    # =====================================================
+    # FOOTER
+    # =====================================================
+
+    gr.Markdown("""
+---
+### 🚀 Features
+
+✅ AI Vehicle Detection  
+✅ License Plate Recognition  
+✅ NLP-to-SQL Query Engine  
+✅ Supabase PostgreSQL Integration  
+✅ Analytics Dashboard  
+✅ Real-time Vehicle Tracking  
+✅ Hugging Face AI Integration  
+""")
+
+# =========================================================
+# ENABLE QUEUE
+# =========================================================
+
+demo.queue()
 
-# ================= LAUNCH ================= #
+# =========================================================
+# LAUNCH
+# =========================================================
 
 if __name__ == "__main__":
 

app_old.py

@@ -0,0 +1,373 @@
+import os
+os.environ['OMP_NUM_THREADS'] = '1'
+
+import re
+from datetime import datetime
+import asyncio
+
+import cv2
+import gradio as gr
+import numpy as np
+import torch
+from PIL import Image
+
+from paddleocr import PaddleOCR
+from ultralytics import YOLO
+from transformers import AutoImageProcessor, AutoModelForImageClassification
+from sqlalchemy import create_engine, text
+from dotenv import load_dotenv
+from huggingface_hub import InferenceClient
+
+# Fix async warning
+asyncio.set_event_loop_policy(asyncio.DefaultEventLoopPolicy())
+
+# Load environment variables
+load_dotenv()
+
+DATABASE_URL = os.getenv("DATABASE_URL")
+engine = create_engine(DATABASE_URL)
+
+HF_TOKEN = os.getenv("HF_TOKEN")
+client = InferenceClient(
+    model="defog/sqlcoder-7b-2",
+    token=HF_TOKEN
+)
+
+# ---------------- LOAD MODELS ---------------- #
+
+# YOLO (plate detection)
+try:
+    yolo_model = YOLO("license-plate-finetune-v1s.pt")
+except Exception as e:
+    print(f"Warning: Failed to load YOLO model: {e}")
+    yolo_model = None
+
+# OCR
+ocr = PaddleOCR(use_angle_cls=True, lang="en", show_log=False)
+
+# Vehicle classification
+try:
+    processor = AutoImageProcessor.from_pretrained("dima806/vehicle_10_types_image_detection")
+    vehicle_model = AutoModelForImageClassification.from_pretrained("dima806/vehicle_10_types_image_detection")
+    device = "cuda" if torch.cuda.is_available() else "cpu"
+    vehicle_model.to(device)
+    vehicle_model.eval()
+except Exception as e:
+    print(f"Warning: Failed to load vehicle classification model: {e}")
+    processor = None
+    vehicle_model = None
+    device = "cpu"
+
+# Regex
+plate_regex = re.compile(r"[A-Z]{2}\d{1,2}[A-Z]{1,3}\d{3,4}")
+
+# Database initialization
+def init_db():
+    with engine.connect() as conn:
+        conn.execute(text("""
+        CREATE TABLE IF NOT EXISTS vehicle_logs (
+            id SERIAL PRIMARY KEY,
+            timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
+            plate TEXT,
+            vehicle_type TEXT,
+            vehicle_conf FLOAT,
+            date TEXT,
+            time TEXT
+        )
+        """))
+        conn.commit()
+
+init_db()
+
+# ---------------- PREPROCESS ---------------- #
+
+def preprocess_plate(crop):
+    gray = cv2.cvtColor(crop, cv2.COLOR_RGB2GRAY)
+    resized = cv2.resize(gray, (320, 96))
+
+    clahe = cv2.createCLAHE(2.0, (8, 8))
+    enhanced = clahe.apply(resized)
+
+    filtered = cv2.bilateralFilter(enhanced, 7, 50, 50)
+
+    kernel = np.array([[0,-1,0],[-1,5,-1],[0,-1,0]])
+    sharp = cv2.filter2D(filtered, -1, kernel)
+
+    return cv2.cvtColor(sharp, cv2.COLOR_GRAY2BGR)
+
+# ---------------- AUGMENT ---------------- #
+
+def build_crops(crop):
+    return [
+        crop,
+        cv2.resize(crop, None, fx=1.2, fy=1.2),
+        cv2.GaussianBlur(crop, (3,3), 0)
+    ]
+
+# ---------------- OCR ---------------- #
+
+def run_ocr(image):
+    return ocr.ocr(image, cls=True)
+
+def parse_ocr(ocr_out):
+    texts, confs = [], []
+
+    if not ocr_out:
+        return texts, confs
+
+    items = ocr_out[0] if isinstance(ocr_out[0], list) else ocr_out
+
+    for item in items:
+        try:
+            text, conf = item[1]
+            texts.append(text)
+            confs.append(float(conf))
+        except:
+            continue
+
+    return texts, confs
+
+# ---------------- CLEAN ---------------- #
+
+def clean_text(text):
+    return re.sub(r"[^A-Z0-9]", "", text.upper())
+
+def fix_common(text):
+    return (
+        text.replace("O", "0")
+        .replace("I", "1")
+        .replace("B", "8")
+        .replace("Z", "2")
+        .replace("S", "5")
+    )
+
+# ---------------- VEHICLE CLASSIFICATION ---------------- #
+
+def classify_vehicle(image_np):
+    try:
+        image_pil = Image.fromarray(image_np)
+
+        inputs = processor(images=image_pil, return_tensors="pt")
+        inputs = {k: v.to(device) for k, v in inputs.items()}
+
+        with torch.no_grad():
+            outputs = vehicle_model(**inputs)
+
+        logits = outputs.logits
+        probs = torch.nn.functional.softmax(logits, dim=-1)
+
+        pred = probs.argmax(-1).item()
+        confidence = float(probs.max().item())
+
+        label = vehicle_model.config.id2label[pred]
+
+        return label, confidence
+
+    except Exception as e:
+        print("Vehicle classification error:", e)
+        return "unknown", 0.0
+
+# ---------------- MAIN PIPELINE ---------------- #
+
+def detect(image):
+    now = datetime.now()
+    date = now.strftime("%Y-%m-%d")
+    time = now.strftime("%H:%M:%S")
+
+    # 🔹 Vehicle classification
+    vehicle_type, vehicle_conf = classify_vehicle(image)
+
+    # 🔹 Plate detection
+    results = yolo_model(image)
+    boxes = results[0].boxes
+
+    if boxes is None or len(boxes) == 0:
+        return f"{date} {time} | {vehicle_type} |", {
+            "date": date,
+            "time": time,
+            "vehicle_type": vehicle_type,
+            "vehicle_confidence": round(vehicle_conf, 3),
+            "plate": ""
+        }
+
+    h, w = image.shape[:2]
+    xyxy = boxes.xyxy.cpu().numpy()
+    confs = boxes.conf.cpu().numpy()
+
+    collected = []
+
+    for i, (x1, y1, x2, y2) in enumerate(xyxy):
+
+        if confs[i] < 0.5:
+            continue
+
+        pad = int(0.12 * max(x2 - x1, y2 - y1))
+
+        l = max(int(x1 - pad), 0)
+        t = max(int(y1 - pad), 0)
+        r = min(int(x2 + pad), w - 1)
+        b = min(int(y2 + pad), h - 1)
+
+        crop = image[t:b, l:r]
+
+        for variant in build_crops(crop):
+            pre = preprocess_plate(variant)
+
+            ocr_out = run_ocr(pre)
+            texts, confs_ocr = parse_ocr(ocr_out)
+
+            for txt, cf in zip(texts, confs_ocr):
+
+                if cf < 0.3:
+                    continue
+
+                norm = fix_common(clean_text(txt))
+
+                if len(norm) < 4:
+                    continue
+
+                collected.append(norm)
+
+    if not collected:
+        plate = ""
+    else:
+        combined = "".join(collected)
+        match = plate_regex.search(combined)
+        plate = match.group(0) if match else combined
+
+    # SAVE TO DATABASE
+    try:
+        with engine.connect() as conn:
+            conn.execute(text("""
+                INSERT INTO vehicle_logs
+                (plate, vehicle_type, vehicle_conf, date, time)
+                VALUES (:plate, :vehicle_type, :vehicle_conf, :date, :time)
+            """), {
+                "plate": plate,
+                "vehicle_type": vehicle_type,
+                "vehicle_conf": float(vehicle_conf),
+                "date": date,
+                "time": time
+            })
+            conn.commit()
+    except Exception as e:
+        print("Database insert error:", e)
+
+    # 🔹 Final Output
+    return f"{date} {time} | {vehicle_type} | {plate}", {
+        "date": date,
+        "time": time,
+        "vehicle_type": vehicle_type,
+        "vehicle_confidence": round(vehicle_conf, 3),
+        "plate": plate
+    }
+
+# ---------------- LLM SQL LAYER (SQLCoder) ---------------- #
+
+def ask_llm(user_query):
+    schema = """
+    Table: vehicle_logs
+    
+    Columns:
+    - id (SERIAL PRIMARY KEY)
+    - timestamp (TIMESTAMP)
+    - plate (TEXT) - License plate number
+    - vehicle_type (TEXT) - Type of vehicle
+    - vehicle_conf (FLOAT) - Detection confidence
+    - date (TEXT) - Date in YYYY-MM-DD format
+    - time (TEXT) - Time in HH:MM:SS format
+    """
+
+    prompt = f"""### Task
+Generate PostgreSQL SQL query for the following question.
+
+### Rules
+- Only SELECT queries allowed
+- Use vehicle_logs table
+- No markdown, no explanation
+- Output SQL only
+- Use appropriate WHERE clauses for filtering
+- Use COUNT(*), SUM(), AVG() for aggregations if needed
+- Order by timestamp DESC for chronological queries
+
+### Schema
+{schema}
+
+### User Question
+{user_query}
+
+### SQL Query
+"""
+
+    try:
+        response = client.text_generation(
+            prompt,
+            max_new_tokens=150,
+            temperature=0.1
+        )
+
+        sql_query = response.strip()
+        
+        # Clean up markdown formatting if present
+        sql_query = sql_query.replace("```sql", "")
+        sql_query = sql_query.replace("```", "")
+        sql_query = sql_query.strip()
+
+        return sql_query
+    
+    except Exception as e:
+        print(f"LLM error: {e}")
+        return f"SELECT * FROM vehicle_logs LIMIT 10; -- Error: {e}"
+
+def run_query(user_query):
+    sql_query = ask_llm(user_query)
+
+    try:
+        with engine.connect() as conn:
+            result = conn.execute(text(sql_query))
+            rows = [dict(row._mapping) for row in result]
+
+        return {
+            "query": user_query,
+            "sql": sql_query,
+            "result": rows
+        }
+
+    except Exception as e:
+        return {
+            "error": str(e),
+            "sql": sql_query
+        }
+
+# ---------------- UI ---------------- #
+
+with gr.Blocks() as demo:
+    gr.Markdown("# 🚗 Vehicle Intelligence System")
+
+    with gr.Tab("Detection"):
+        img = gr.Image(type="numpy")
+        out1 = gr.Textbox(label="Result")
+        out2 = gr.JSON(label="Structured Output")
+        btn = gr.Button("Detect")
+
+        btn.click(
+            fn=detect,
+            inputs=img,
+            outputs=[out1, out2]
+        )
+
+    with gr.Tab("Ask Database"):
+        query_input = gr.Textbox(
+            label="Ask Anything",
+            placeholder="How many cars today?"
+        )
+        query_output = gr.JSON()
+        ask_btn = gr.Button("Ask")
+
+        ask_btn.click(
+            fn=run_query,
+            inputs=query_input,
+            outputs=query_output
+        )
+
+demo.launch(server_name="0.0.0.0", server_port=7860)

database.py

@@ -1,211 +1,266 @@
-import os
+# =========================================================
+# ULTRA ADVANCED HYBRID NLP TO SQL ENGINE
+# RULE BASED + LLM BASED + SQL SAFETY
+# MISTRAL / SQLCODER READY
+# =========================================================
+
+import re
 import traceback
-from datetime import datetime
+import os
 
-from dotenv import load_dotenv
 from huggingface_hub import InferenceClient
+from dotenv import load_dotenv
 from sqlalchemy import create_engine, text
 
-load_dotenv()
+# =========================================================
+# ENVIRONMENT SETUP
+# =========================================================
 
-# ================= DATABASE ================= #
+load_dotenv()
 
+HF_TOKEN = os.getenv("HF_TOKEN")
 DATABASE_URL = os.getenv("DATABASE_URL")
-engine = None
-db_available = False
 
-if DATABASE_URL:
-    try:
-        engine = create_engine(
-            DATABASE_URL,
-            pool_pre_ping=True
-        )
-        db_available = True
-        print("✅ Database engine initialized")
-    except Exception as e:
-        print(f"⚠️ Database initialization error: {e}")
-        db_available = False
-else:
-    print("⚠️ DATABASE_URL not set. Database features disabled.")
+# Initialize Mistral client
+client = InferenceClient(
+    model="mistralai/Mistral-7B-Instruct-v0.2",
+    token=HF_TOKEN
+)
 
-# ================= HUGGINGFACE ================= #
+# Initialize database engine
+try:
+    engine = create_engine(DATABASE_URL)
+    print("✅ Database connection initialized")
+except Exception as e:
+    print(f"⚠️ Database connection warning: {e}")
+    engine = None
+
+# =========================================================
+# CONFIG
+# =========================================================
+
+USE_LLM = True
+
+# =========================================================
+# DATABASE KNOWLEDGE
+# =========================================================
+
+SCHEMA = {
+    "table": "vehicle_logs",
+    "columns": [
+        "timestamp",
+        "plate",
+        "state",
+        "vehicle_type",
+        "vehicle_conf",
+        "camera_id",
+        "location",
+        "date",
+        "hour",
+        "day"
+    ]
+}
 
-HF_TOKEN = os.getenv("HF_TOKEN")
-client = None
+VALID_STATES = {
+    "tn": "TN",
+    "tamil nadu": "TN",
 
-if HF_TOKEN:
-    try:
-        client = InferenceClient(
-            model="defog/sqlcoder-7b-2",
-            token=HF_TOKEN
-        )
-        print("✅ HuggingFace client initialized")
-    except Exception as e:
-        print(f"⚠️ HuggingFace client error: {e}")
-else:
-    print("⚠️ HF_TOKEN not set. NLP-to-SQL features disabled.")
+    "ka": "KA",
+    "karnataka": "KA",
 
-# ================= INIT DB ================= #
+    "kl": "KL",
+    "kerala": "KL",
 
-def init_db():
-    
-    if not db_available or engine is None:
-        print("⚠️ Skipping database initialization - DATABASE_URL not configured")
-        return
+    "ap": "AP",
+    "andhra": "AP",
 
-    try:
-        with engine.begin() as conn:
-            # Create table if it doesn't exist
-            conn.execute(text("""
-            CREATE TABLE IF NOT EXISTS vehicle_logs (
-                id BIGSERIAL PRIMARY KEY,
-                timestamp TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-                plate TEXT,
-                state TEXT,
-                vehicle_type TEXT,
-                vehicle_conf FLOAT,
-                date DATE,
-                hour INTEGER,
-                day TEXT
-            )
-            """))
-
-        print("✅ Database Initialized")
-        
-    except Exception as e:
-        print(f"⚠️ Database initialization error: {e}")
-        traceback.print_exc()
+    "ts": "TS",
+    "telangana": "TS",
 
+    "mh": "MH",
+    "maharashtra": "MH",
 
-init_db()
+    "dl": "DL",
+    "delhi": "DL",
 
-# ================= SAVE ================= #
+    "gj": "GJ",
+    "gujarat": "GJ",
 
-def save_detection(
-    plate,
-    state,
-    vehicle_type,
-    vehicle_conf,
-    date_str,
-    time_str
-):
-    
-    if not db_available or engine is None:
-        print("⚠️ Database not available for saving detection")
-        return
+    "rj": "RJ",
+    "rajasthan": "RJ",
 
-    try:
-        dt = datetime.strptime(
-            f"{date_str} {time_str}",
-            "%Y-%m-%d %H:%M:%S"
-        )
+    "up": "UP",
+    "uttar pradesh": "UP",
 
-        hour = dt.hour
-        day = dt.strftime("%A")
+    "wb": "WB",
+    "west bengal": "WB",
 
-        with engine.begin() as conn:
-            conn.execute(text("""
-            INSERT INTO vehicle_logs
-            (
-                plate,
-                state,
-                vehicle_type,
-                vehicle_conf,
-                date,
-                hour,
-                day
-            )
-            VALUES
-            (
-                :plate,
-                :state,
-                :vehicle_type,
-                :vehicle_conf,
-                :date,
-                :hour,
-                :day
-            )
-            """), {
-                "plate": plate,
-                "state": state,
-                "vehicle_type": vehicle_type,
-                "vehicle_conf": float(vehicle_conf),
-                "date": date_str,
-                "hour": hour,
-                "day": day
-            })
-    
-    except Exception as e:
-        print(f"⚠️ Error saving detection: {e}")
-        traceback.print_exc()
+    "hr": "HR",
+    "haryana": "HR",
 
+    "pb": "PB",
+    "punjab": "PB"
+}
 
-# ================= SQL SAFETY ================= #
+KNOWN_LOCATIONS = [
+    "adyar",
+    "guindy",
+    "velachery",
+    "besantnagar",
+    "besant nagar",
+    "thiruvanmiyur",
+    "tnagar",
+    "t nagar",
+    "mylapore",
+    "annanagar",
+    "anna nagar",
+    "koyambedu",
+    "nungambakkam",
+    "kotturpuram"
+]
 
-BLOCKED = [
-    "DROP",
-    "DELETE",
-    "UPDATE",
-    "INSERT",
-    "ALTER",
-    "TRUNCATE"
+VEHICLE_TYPES = [
+    "suv",
+    "bus",
+    "truck",
+    "bike",
+    "auto",
+    "taxi",
+    "car",
+    "jeep",
+    "sedan"
 ]
 
+# =========================================================
+# SQL CLEANER
+# =========================================================
+
+def clean_sql(sql):
+
+    sql = sql.replace("```sql", "")
+    sql = sql.replace("```", "")
+    sql = sql.strip()
+
+    if not sql.endswith(";"):
+        sql += ";"
+
+    return sql
+
+
+# =========================================================
+# SQL VALIDATOR
+# =========================================================
+
 def validate_sql(sql):
 
+    blocked = [
+        "DROP",
+        "DELETE",
+        "UPDATE",
+        "INSERT",
+        "ALTER",
+        "CREATE",
+        "TRUNCATE",
+        "JOIN",
+        "UNION"
+    ]
+
     upper = sql.upper()
 
-    for word in BLOCKED:
+    for word in blocked:
 
         if word in upper:
             return False
 
-    return upper.startswith("SELECT")
+    if not upper.startswith("SELECT"):
+        return False
 
+    if "VEHICLE_LOGS" not in upper:
+        return False
 
-# ================= NLP TO SQL ================= #
+    return True
 
-# ================= HELPER FUNCTIONS ================= #
 
-def clean_sql(sql_str):
-    """Clean and normalize SQL output"""
-    
-    sql = sql_str.strip()
-    sql = sql.replace("```sql", "").replace("```", "")
-    sql = sql.strip()
-    
-    if not sql.endswith(";"):
-        sql += ";"
-    
-    return sql
-
-
-# ================= NLP TO SQL ================= #
+# =========================================================
+# MAIN NLP TO SQL ENGINE
+# =========================================================
 
 def ask_llm(user_query):
-    """
-    Advanced NLP-to-SQL Generator
-    Hybrid Rule-Based + LLM Approach for Vehicle Intelligence
-    """
-
-    import re
-
-    if client is None:
-        return "SELECT * FROM vehicle_logs LIMIT 10;"
 
     q = user_query.lower().strip()
 
-    # =========================================================
-    # RULE-BASED FAST PATHS (VERY IMPORTANT)
-    # =========================================================
+    # =====================================================
+    # ENTITY EXTRACTION
+    # =====================================================
+
+    plate_match = re.search(
+        r'([A-Z]{2}\d{1,2}[A-Z]{1,3}\d{3,4})',
+        user_query.upper()
+    )
+
+    date_match = re.search(
+        r'(\d{4}-\d{2}-\d{2})',
+        q
+    )
+
+    # =====================================================
+    # INTENT DETECTION
+    # =====================================================
+
+    intents = {
+
+        "tracking":
+            any(k in q for k in [
+                "track",
+                "history",
+                "movement",
+                "travel",
+                "route",
+                "visited",
+                "where"
+            ]),
+
+        "count":
+            any(k in q for k in [
+                "count",
+                "how many",
+                "total"
+            ]),
+
+        "analytics":
+            any(k in q for k in [
+                "top",
+                "most",
+                "distribution",
+                "analysis",
+                "statistics",
+                "peak"
+            ]),
+
+        "latest":
+            any(k in q for k in [
+                "latest",
+                "recent",
+                "last"
+            ])
+    }
+
+    # =====================================================
+    # RULE BASED ENGINE
+    # =====================================================
 
-    # ----- PLATE TRACKING (Generic) -----
-    plate_match = re.search(r'([A-Z]{2}\d{1,2}[A-Z]{1,3}\d{3,4})', user_query.upper())
+    # =====================================================
+    # PLATE TRACKING
+    # =====================================================
 
     if plate_match:
+
         plate = plate_match.group(1)
 
-        if any(k in q for k in ["location", "route", "travel", "movement", "where", "pass", "track", "history"]):
+        # TRACKING
+
+        if intents["tracking"]:
+
             return clean_sql(f"""
             SELECT
                 timestamp,
@@ -213,456 +268,466 @@ def ask_llm(user_query):
                 state,
                 vehicle_type,
                 location,
-                camera_id
+                camera_id,
+                date,
+                hour,
+                day
             FROM vehicle_logs
             WHERE plate = '{plate}'
             ORDER BY timestamp DESC
-            LIMIT 100;
+            LIMIT 100
             """)
 
-        if any(k in q for k in ["count", "how many", "detections"]):
+        # COUNT
+
+        if intents["count"]:
+
             return clean_sql(f"""
             SELECT
                 plate,
-                COUNT(*) as detection_count,
+                COUNT(*) as detections,
                 COUNT(DISTINCT location) as unique_locations,
-                COUNT(DISTINCT date) as days_detected
+                COUNT(DISTINCT date) as active_days
             FROM vehicle_logs
             WHERE plate = '{plate}'
-            GROUP BY plate;
+            GROUP BY plate
             """)
 
+        # DEFAULT
+
         return clean_sql(f"""
         SELECT *
         FROM vehicle_logs
         WHERE plate = '{plate}'
         ORDER BY timestamp DESC
-        LIMIT 50;
+        LIMIT 50
         """)
 
-    # ----- STATE SEARCH (Generic) -----
-    states_map = {
-        "tn": "TN", "tamil": "TN", "tamil nadu": "TN",
-        "ka": "KA", "karnataka": "KA",
-        "kl": "KL", "kerala": "KL",
-        "ap": "AP", "andhra": "AP",
-        "ts": "TS", "telangana": "TS",
-        "mh": "MH", "maharashtra": "MH",
-        "dl": "DL", "delhi": "DL",
-        "gj": "GJ", "gujarat": "GJ",
-        "rj": "RJ", "rajasthan": "RJ",
-        "up": "UP", "uttar": "UP",
-        "wb": "WB", "bengal": "WB",
-        "hr": "HR", "haryana": "HR",
-        "pb": "PB", "punjab": "PB"
-    }
+    # =====================================================
+    # STATE QUERIES
+    # =====================================================
+
+    for key, state in VALID_STATES.items():
 
-    for key, state_code in states_map.items():
         if key in q:
-            if "count" in q:
+
+            if intents["count"]:
+
                 return clean_sql(f"""
                 SELECT
                     state,
-                    COUNT(*) as total_vehicles,
-                    COUNT(DISTINCT plate) as unique_plates,
-                    COUNT(DISTINCT location) as locations_active
+                    COUNT(*) as total_detections,
+                    COUNT(DISTINCT plate) as unique_vehicles
                 FROM vehicle_logs
-                WHERE state = '{state_code}'
-                GROUP BY state;
-                """)
-            
-            if "distribution" in q or "breakdown" in q:
-                return clean_sql(f"""
-                SELECT
-                    vehicle_type,
-                    COUNT(*) as count
-                FROM vehicle_logs
-                WHERE state = '{state_code}'
-                GROUP BY vehicle_type
-                ORDER BY count DESC;
+                WHERE state = '{state}'
+                GROUP BY state
                 """)
 
             return clean_sql(f"""
             SELECT *
             FROM vehicle_logs
-            WHERE state = '{state_code}'
+            WHERE state = '{state}'
             ORDER BY timestamp DESC
-            LIMIT 50;
+            LIMIT 100
             """)
 
-    # ----- LOCATION SEARCH (Generic) -----
-    locations = [
-        "adyar", "guindy", "velachery", "besant", "thiruvanmiyur",
-        "tnagar", "mylapore", "annanagar", "koyambedu", "nungambakkam",
-        "kotturpuram", "porur", "indiranagar", "whitefield", "koramangala",
-        "bangalore", "hyderabad", "trivandrum", "kochi", "pune", "mumbai"
-    ]
+    # =====================================================
+    # LOCATION QUERIES
+    # =====================================================
+
+    for loc in KNOWN_LOCATIONS:
 
-    for loc in locations:
         if loc in q:
-            if "count" in q:
+
+            # COUNT
+
+            if intents["count"]:
+
                 return clean_sql(f"""
                 SELECT
                     location,
-                    COUNT(*) as detection_count,
+                    COUNT(*) as detections,
                     COUNT(DISTINCT plate) as unique_vehicles
                 FROM vehicle_logs
                 WHERE LOWER(location) LIKE '%{loc}%'
                 GROUP BY location
-                ORDER BY detection_count DESC;
+                ORDER BY detections DESC
                 """)
 
+            # DEFAULT
+
             return clean_sql(f"""
             SELECT
                 timestamp,
                 plate,
                 state,
                 vehicle_type,
-                location
+                location,
+                camera_id
             FROM vehicle_logs
             WHERE LOWER(location) LIKE '%{loc}%'
             ORDER BY timestamp DESC
-            LIMIT 100;
+            LIMIT 100
             """)
 
-    # ----- VEHICLE TYPE SEARCH (Generic) -----
-    vehicle_types = {
-        "suv": "SUV", "sedan": "Sedan", "hatchback": "Hatchback",
-        "truck": "Truck", "bus": "Bus", "bike": "Bike",
-        "motorcycle": "Bike", "auto": "Auto", "taxi": "Taxi",
-        "car": "Car", "van": "Van", "tempo": "Tempo"
-    }
+    # =====================================================
+    # VEHICLE TYPE
+    # =====================================================
+
+    for vtype in VEHICLE_TYPES:
+
+        if vtype in q:
+
+            if intents["count"]:
 
-    for vtype_key, vtype_val in vehicle_types.items():
-        if vtype_key in q:
-            if "count" in q:
                 return clean_sql(f"""
                 SELECT
                     vehicle_type,
-                    COUNT(*) as count,
-                    ROUND(AVG(vehicle_conf), 2) as avg_confidence
+                    COUNT(*) as count
                 FROM vehicle_logs
-                WHERE LOWER(vehicle_type) LIKE '%{vtype_val.lower()}%'
-                GROUP BY vehicle_type;
+                WHERE LOWER(vehicle_type) LIKE '%{vtype}%'
+                GROUP BY vehicle_type
                 """)
 
             return clean_sql(f"""
             SELECT *
             FROM vehicle_logs
-            WHERE LOWER(vehicle_type) LIKE '%{vtype_val.lower()}%'
+            WHERE LOWER(vehicle_type) LIKE '%{vtype}%'
             ORDER BY timestamp DESC
-            LIMIT 50;
+            LIMIT 50
             """)
 
-    # ----- DATE SEARCH -----
-    date_match = re.search(r'(\d{4}-\d{2}-\d{2})', q)
+    # =====================================================
+    # DATE QUERY
+    # =====================================================
 
     if date_match:
-        date_value = date_match.group(1)
 
-        if "count" in q:
-            return clean_sql(f"""
-            SELECT
-                date,
-                COUNT(*) as total_detections,
-                COUNT(DISTINCT plate) as unique_vehicles,
-                COUNT(DISTINCT location) as unique_locations
-            FROM vehicle_logs
-            WHERE date = '{date_value}'
-            GROUP BY date;
-            """)
+        d = date_match.group(1)
 
         return clean_sql(f"""
         SELECT *
         FROM vehicle_logs
-        WHERE date = '{date_value}'
+        WHERE date = '{d}'
         ORDER BY timestamp DESC
-        LIMIT 100;
+        LIMIT 100
         """)
 
-    # ----- TIME-BASED QUERIES -----
-    if "morning" in q:
-        return clean_sql("""
-        SELECT *
-        FROM vehicle_logs
-        WHERE hour BETWEEN 6 AND 11
-        ORDER BY timestamp DESC
-        LIMIT 100;
-        """)
+    # =====================================================
+    # ANALYTICS
+    # =====================================================
 
-    if "afternoon" in q:
-        return clean_sql("""
-        SELECT *
-        FROM vehicle_logs
-        WHERE hour BETWEEN 12 AND 17
-        ORDER BY timestamp DESC
-        LIMIT 100;
-        """)
-
-    if "evening" in q or "night" in q:
-        return clean_sql("""
-        SELECT *
-        FROM vehicle_logs
-        WHERE hour BETWEEN 18 AND 23 OR hour BETWEEN 0 AND 5
-        ORDER BY timestamp DESC
-        LIMIT 100;
-        """)
+    if "hourly traffic" in q or "traffic by hour" in q:
 
-    if "busiest hour" in q or "peak hour" in q:
         return clean_sql("""
         SELECT
             hour,
-            COUNT(*) as traffic_volume
+            COUNT(*) as traffic
         FROM vehicle_logs
         GROUP BY hour
-        ORDER BY traffic_volume DESC
-        LIMIT 1;
+        ORDER BY hour
         """)
 
-    if "hourly traffic" in q or "traffic by hour" in q:
-        return clean_sql("""
-        SELECT
-            hour,
-            COUNT(*) as traffic_count,
-            COUNT(DISTINCT plate) as unique_vehicles
-        FROM vehicle_logs
-        GROUP BY hour
-        ORDER BY hour;
-        """)
+    if "top vehicles" in q or "most detected" in q:
 
-    # ----- ANALYTICS QUERIES -----
-    if "top plates" in q or "most detected" in q or "repeated plates" in q:
         return clean_sql("""
         SELECT
             plate,
-            COUNT(*) as detections,
-            COUNT(DISTINCT location) as locations,
-            COUNT(DISTINCT date) as days
+            COUNT(*) as detections
         FROM vehicle_logs
         GROUP BY plate
         ORDER BY detections DESC
-        LIMIT 20;
+        LIMIT 20
         """)
 
-    if "suspicious" in q or "high frequency" in q or "unusual" in q:
+    if "state distribution" in q:
+
         return clean_sql("""
         SELECT
-            plate,
-            COUNT(*) as detection_count,
-            COUNT(DISTINCT location) as unique_locations,
-            ROUND(AVG(vehicle_conf), 2) as avg_confidence
+            state,
+            COUNT(*) as count
         FROM vehicle_logs
-        GROUP BY plate
-        HAVING COUNT(*) > 10
-        ORDER BY detection_count DESC
-        LIMIT 50;
+        GROUP BY state
+        ORDER BY count DESC
         """)
 
-    if "vehicle type" in q and ("count" in q or "distribution" in q or "breakdown" in q):
+    if "vehicle type distribution" in q:
+
         return clean_sql("""
         SELECT
             vehicle_type,
-            COUNT(*) as count,
-            ROUND(100.0 * COUNT(*) / (SELECT COUNT(*) FROM vehicle_logs), 2) as percentage,
-            ROUND(AVG(vehicle_conf), 2) as avg_confidence
+            COUNT(*) as count
         FROM vehicle_logs
         GROUP BY vehicle_type
-        ORDER BY count DESC;
+        ORDER BY count DESC
         """)
 
-    if "state distribution" in q or ("count" in q and "state" in q):
-        return clean_sql("""
-        SELECT
-            state,
-            COUNT(*) as count,
-            COUNT(DISTINCT plate) as unique_plates,
-            ROUND(100.0 * COUNT(*) / (SELECT COUNT(*) FROM vehicle_logs), 2) as percentage
-        FROM vehicle_logs
-        GROUP BY state
-        ORDER BY count DESC;
-        """)
+    if "latest" in q or "recent" in q:
 
-    if "latest" in q or "recent" in q or "last detection" in q:
         return clean_sql("""
         SELECT *
         FROM vehicle_logs
         ORDER BY timestamp DESC
-        LIMIT 50;
+        LIMIT 50
         """)
 
-    if "total vehicle" in q or "total count" in q:
-        return clean_sql("""
-        SELECT
-            COUNT(*) as total_detections,
-            COUNT(DISTINCT plate) as unique_vehicles,
-            COUNT(DISTINCT state) as states_active,
-            COUNT(DISTINCT location) as locations_active
-        FROM vehicle_logs;
-        """)
+    # =====================================================
+    # LLM FALLBACK
+    # =====================================================
 
-    if "camera" in q or "detection point" in q:
-        return clean_sql("""
-        SELECT
-            camera_id,
-            location,
-            COUNT(*) as detections,
-            COUNT(DISTINCT plate) as unique_vehicles
-        FROM vehicle_logs
-        WHERE camera_id IS NOT NULL
-        GROUP BY camera_id, location
-        ORDER BY detections DESC
-        LIMIT 20;
-        """)
+    if not USE_LLM:
 
-    # ----- ADVANCED COMBINATION QUERIES -----
-    if "passed through" in q or "traveled through" in q:
         return clean_sql("""
-        SELECT
-            plate,
-            location,
-            COUNT(*) as times_detected,
-            MIN(timestamp) as first_detection,
-            MAX(timestamp) as last_detection
+        SELECT *
         FROM vehicle_logs
-        WHERE location IS NOT NULL
-        GROUP BY plate, location
-        ORDER BY plate, MIN(timestamp) DESC
-        LIMIT 100;
+        ORDER BY timestamp DESC
+        LIMIT 10
         """)
 
-    # =========================================================
-    # FALLBACK: ADVANCED LLM
-    # =========================================================
-
-    prompt = f"""
-You are an expert PostgreSQL SQL generator for vehicle intelligence.
-
-DATABASE SCHEMA:
-vehicle_logs(
-    timestamp,
-    plate,
-    state,
-    vehicle_type,
-    vehicle_conf,
-    camera_id,
-    location,
-    date,
-    hour,
-    day
-)
+    # =====================================================
+    # SYSTEM PROMPT
+    # =====================================================
+
+    system_prompt = f"""
+You are an elite PostgreSQL SQL generator.
+
+Your job:
+Convert natural language into VALID PostgreSQL SQL.
+
+==================================================
+DATABASE
+==================================================
+
+TABLE:
+vehicle_logs
+
+AVAILABLE COLUMNS:
+
+timestamp
+plate
+state
+vehicle_type
+vehicle_conf
+camera_id
+location
+date
+hour
+day
 
-VALID COLUMNS:
-timestamp - Detection timestamp
-plate - License plate number
-state - State code (TN, KA, KL, AP, TS, MH, DL, GJ, RJ, UP, WB, HR, PB)
-vehicle_type - Car, SUV, Truck, Bus, Bike, Auto, Taxi, Van, etc.
-vehicle_conf - Detection confidence (0.0-1.0)
-camera_id - Camera identifier
-location - Detection location/area name
-date - Detection date (YYYY-MM-DD)
-hour - Hour of day (0-23)
-day - Day of week (Monday-Sunday)
-
-STRICT RULES:
-1. ONLY SELECT queries
-2. NEVER JOIN tables
-3. NEVER use subqueries (except COUNT aggregates)
-4. ONLY vehicle_logs table
-5. ALWAYS use LIMIT 50 or LIMIT 100
-6. NEVER use DELETE, UPDATE, DROP, ALTER, CREATE, TRUNCATE
-7. NEVER invent columns or tables
-8. Return SQL ONLY (no explanation)
-9. No markdown formatting
-10. Always end with semicolon
-
-EXAMPLES:
-
-Q: Show TN vehicles
-A: SELECT * FROM vehicle_logs WHERE state='TN' ORDER BY timestamp DESC LIMIT 50;
-
-Q: Show all vehicles from Adyar
-A: SELECT * FROM vehicle_logs WHERE LOWER(location) LIKE '%adyar%' ORDER BY timestamp DESC LIMIT 50;
-
-Q: Show suspicious vehicles
-A: SELECT plate, COUNT(*) as count FROM vehicle_logs GROUP BY plate HAVING COUNT(*) > 10 ORDER BY count DESC LIMIT 50;
-
-Q: Show vehicle type distribution
-A: SELECT vehicle_type, COUNT(*) as count FROM vehicle_logs GROUP BY vehicle_type ORDER BY count DESC;
-
-Q: Show hourly traffic
-A: SELECT hour, COUNT(*) as count FROM vehicle_logs GROUP BY hour ORDER BY hour;
-
-Q: Show latest detections
-A: SELECT * FROM vehicle_logs ORDER BY timestamp DESC LIMIT 50;
-
-Q: Track vehicle TN63AB1234
-A: SELECT * FROM vehicle_logs WHERE plate='TN63AB1234' ORDER BY timestamp DESC LIMIT 100;
-
-USER QUESTION:
-{user_query}
+==================================================
+COLUMN MEANINGS
+==================================================
+
+timestamp:
+vehicle detection timestamp
 
-SQL:
+plate:
+vehicle number plate
+
+state:
+vehicle state code
+
+vehicle_type:
+type of vehicle
+
+vehicle_conf:
+AI detection confidence
+
+camera_id:
+CCTV camera ID
+
+location:
+detected location
+
+date:
+YYYY-MM-DD
+
+hour:
+0-23
+
+day:
+Monday-Sunday
+
+==================================================
+KNOWN STATES
+==================================================
+
+TN
+KA
+KL
+AP
+TS
+MH
+DL
+GJ
+RJ
+UP
+WB
+HR
+PB
+
+==================================================
+KNOWN LOCATIONS
+==================================================
+
+{KNOWN_LOCATIONS}
+
+==================================================
+STRICT RULES
+==================================================
+
+1. ONLY use vehicle_logs
+2. NEVER use JOIN
+3. NEVER invent tables
+4. NEVER invent columns
+5. ONLY SELECT queries
+6. NEVER use UPDATE
+7. NEVER use DELETE
+8. NEVER use DROP
+9. NEVER use ALTER
+10. PostgreSQL syntax only
+11. Always use LIMIT 50 or LIMIT 100
+12. Return SQL ONLY
+13. No markdown
+14. No explanation
+
+==================================================
+QUERY UNDERSTANDING
+==================================================
+
+track vehicle
+→ WHERE plate=''
+
+show TN vehicles
+→ WHERE state='TN'
+
+show vehicles from adyar
+→ WHERE LOWER(location) LIKE '%adyar%'
+
+top vehicles
+→ GROUP BY plate
+
+hourly traffic
+→ GROUP BY hour
+
+vehicle type distribution
+→ GROUP BY vehicle_type
+
+latest detections
+→ ORDER BY timestamp DESC
+
+==================================================
+GOOD EXAMPLES
+==================================================
+
+SELECT *
+FROM vehicle_logs
+WHERE state='TN'
+ORDER BY timestamp DESC
+LIMIT 50;
+
+SELECT *
+FROM vehicle_logs
+WHERE LOWER(location) LIKE '%adyar%'
+ORDER BY timestamp DESC
+LIMIT 50;
+
+SELECT
+plate,
+COUNT(*) as detections
+FROM vehicle_logs
+GROUP BY plate
+ORDER BY detections DESC
+LIMIT 20;
+
+SELECT *
+FROM vehicle_logs
+WHERE plate='TN63MB3157'
+ORDER BY timestamp DESC
+LIMIT 100;
+"""
+
+    user_prompt = f"""
+Generate PostgreSQL SQL query for:
+
+{user_query}
 """
 
+    # =====================================================
+    # MISTRAL / SQLCODER CALL
+    # =====================================================
+
     try:
-        response = client.text_generation(
-            prompt,
-            max_new_tokens=150,
-            temperature=0.05,
-            repetition_penalty=1.2
+
+        response = client.chat_completion(
+            messages=[
+                {
+                    "role": "system",
+                    "content": system_prompt
+                },
+                {
+                    "role": "user",
+                    "content": user_prompt
+                }
+            ],
+            max_tokens=250,
+            temperature=0.05
         )
 
-        sql_query = clean_sql(response.strip())
+        sql = response.choices[0].message.content.strip()
 
-        # =====================================================
-        # EXTRA SAFETY VALIDATION
-        # =====================================================
+        sql = clean_sql(sql)
 
-        sql_upper = sql_query.upper()
+        # =================================================
+        # SAFETY
+        # =================================================
 
-        blocked = ["DROP", "DELETE", "UPDATE", "INSERT", "ALTER", "CREATE", "TRUNCATE", "JOIN", "UNION"]
+        if not validate_sql(sql):
 
-        for b in blocked:
-            if b in sql_upper:
-                return f"SELECT * FROM vehicle_logs LIMIT 10;"  # Fallback
+            return clean_sql("""
+            SELECT *
+            FROM vehicle_logs
+            ORDER BY timestamp DESC
+            LIMIT 10
+            """)
 
-        if "VEHICLE_LOGS" not in sql_upper:
-            return f"SELECT * FROM vehicle_logs LIMIT 10;"  # Fallback
+        # AUTO LIMIT
 
-        if not sql_upper.startswith("SELECT"):
-            return f"SELECT * FROM vehicle_logs LIMIT 10;"  # Fallback
+        if "LIMIT" not in sql.upper():
 
-        return sql_query
+            sql = sql.replace(";", " LIMIT 50;")
+
+        return sql
 
     except Exception as e:
-        print(f"⚠️ LLM Error: {e}")
-        return f"SELECT * FROM vehicle_logs LIMIT 10;"  # Fallback
 
+        print("LLM ERROR:", e)
+        traceback.print_exc()
 
-# ================= QUERY ================= #
+        return clean_sql("""
+        SELECT *
+        FROM vehicle_logs
+        ORDER BY timestamp DESC
+        LIMIT 10
+        """)
 
-def run_query(user_query):
+# =========================================================
+# QUERY EXECUTION
+# =========================================================
 
-    if not db_available or engine is None:
-        return {
-            "query": user_query,
-            "error": "Database not configured. Set DATABASE_URL in Hugging Face Spaces secrets.",
-            "sql": None,
-            "result": []
-        }
+def run_query(user_query):
 
     try:
 
         sql = ask_llm(user_query)
 
-        if not validate_sql(sql):
+        print("\n==============================")
+        print("USER QUERY:")
+        print(user_query)
 
-            return {
-                "query": user_query,
-                "error": "Unsafe SQL blocked",
-                "sql": sql,
-                "result": []
-            }
+        print("\nGENERATED SQL:")
+        print(sql)
+        print("==============================")
 
         with engine.connect() as conn:
 
@@ -676,8 +741,8 @@ def run_query(user_query):
         return {
             "query": user_query,
             "sql": sql,
-            "result": rows,
-            "count": len(rows)
+            "count": len(rows),
+            "result": rows
         }
 
     except Exception as e:
@@ -691,104 +756,148 @@ def run_query(user_query):
             "result": []
         }
 
+# =========================================================
+# DATABASE OPERATIONS
+# =========================================================
 
-# ================= ANALYTICS ================= #
-
-def get_vehicles_by_state():
-
-    if not db_available or engine is None:
-        return []
-
+def save_detection(plate, state, vehicle_type, vehicle_conf, date, time):
+    """Save a vehicle detection to the database"""
+    
     try:
+        
+        if engine is None:
+            print("⚠️ Engine not initialized")
+            return False
+        
+        query = f"""
+        INSERT INTO vehicle_logs 
+        (plate, state, vehicle_type, vehicle_conf, date, time, timestamp)
+        VALUES ('{plate}', '{state}', '{vehicle_type}', {vehicle_conf}, '{date}', '{time}', NOW())
+        """
+        
         with engine.connect() as conn:
-            result = conn.execute(text("""
-            SELECT state, COUNT(*) AS count
-            FROM vehicle_logs
-            GROUP BY state
-            ORDER BY count DESC
-            """))
-            return [dict(r._mapping) for r in result]
+            conn.execute(text(query))
+            conn.commit()
+            
+        print(f"✅ Saved: {plate} from {state}")
+        return True
+        
     except Exception as e:
-        print(f"⚠️ Error in get_vehicles_by_state: {e}")
-        return []
+        print(f"Save Error: {e}")
+        traceback.print_exc()
+        return False
 
 
-def get_hourly_traffic():
+def health_check():
+    """Check database health"""
+    
+    try:
+        
+        if engine is None:
+            return False, "❌ Database not configured"
+        
+        with engine.connect() as conn:
+            result = conn.execute(text("SELECT COUNT(*) FROM vehicle_logs"))
+            count = result.scalar()
+            
+        return True, f"✅ Database OK - {count} records"
+        
+    except Exception as e:
+        return False, f"❌ Database Error: {str(e)}"
 
-    if not db_available or engine is None:
-        return []
 
+def get_vehicles_by_state():
+    """Get vehicle count by state"""
+    
     try:
+        
+        sql = """
+        SELECT state, COUNT(*) as count
+        FROM vehicle_logs
+        GROUP BY state
+        ORDER BY count DESC
+        """
+        
         with engine.connect() as conn:
-            result = conn.execute(text("""
-            SELECT hour, COUNT(*) AS count
-            FROM vehicle_logs
-            GROUP BY hour
-            ORDER BY hour
-            """))
-            return [dict(r._mapping) for r in result]
+            result = conn.execute(text(sql))
+            rows = [dict(r._mapping) for r in result]
+            
+        return rows
+        
     except Exception as e:
-        print(f"⚠️ Error in get_hourly_traffic: {e}")
+        print(f"State Query Error: {e}")
         return []
 
 
-def get_top_plates():
-
-    if not db_available or engine is None:
-        return []
-
+def get_hourly_traffic():
+    """Get traffic by hour"""
+    
     try:
+        
+        sql = """
+        SELECT hour, COUNT(*) as traffic
+        FROM vehicle_logs
+        GROUP BY hour
+        ORDER BY hour
+        """
+        
         with engine.connect() as conn:
-            result = conn.execute(text("""
-            SELECT plate, COUNT(*) AS count
-            FROM vehicle_logs
-            WHERE plate != ''
-            GROUP BY plate
-            ORDER BY count DESC
-            LIMIT 10
-            """))
-            return [dict(r._mapping) for r in result]
+            result = conn.execute(text(sql))
+            rows = [dict(r._mapping) for r in result]
+            
+        return rows
+        
     except Exception as e:
-        print(f"⚠️ Error in get_top_plates: {e}")
+        print(f"Hourly Traffic Error: {e}")
         return []
 
 
-def get_suspicious_vehicles():
-
-    if not db_available or engine is None:
-        return []
-
+def get_top_plates():
+    """Get top detected plates"""
+    
     try:
+        
+        sql = """
+        SELECT plate, COUNT(*) as detections
+        FROM vehicle_logs
+        GROUP BY plate
+        ORDER BY detections DESC
+        LIMIT 20
+        """
+        
         with engine.connect() as conn:
-            result = conn.execute(text("""
-            SELECT plate,
-                   COUNT(*) AS detections
-            FROM vehicle_logs
-            GROUP BY plate
-            HAVING COUNT(*) > 5
-            ORDER BY detections DESC
-            LIMIT 20
-            """))
-            return [dict(r._mapping) for r in result]
+            result = conn.execute(text(sql))
+            rows = [dict(r._mapping) for r in result]
+            
+        return rows
+        
     except Exception as e:
-        print(f"⚠️ Error in get_suspicious_vehicles: {e}")
+        print(f"Top Plates Error: {e}")
         return []
 
 
-# ================= HEALTH ================= #
-
-def health_check():
-
-    if not db_available or engine is None:
-        return False, "⚠️ Database not configured. Set DATABASE_URL in Hugging Face Spaces secrets."
-
+def get_suspicious_vehicles():
+    """Get vehicles detected multiple times (potentially suspicious)"""
+    
     try:
-
+        
+        sql = """
+        SELECT plate, state, COUNT(*) as detections, 
+               COUNT(DISTINCT location) as locations,
+               COUNT(DISTINCT date) as days
+        FROM vehicle_logs
+        GROUP BY plate, state
+        HAVING COUNT(*) > 5
+        ORDER BY detections DESC
+        LIMIT 20
+        """
+        
         with engine.connect() as conn:
-            conn.execute(text("SELECT 1"))
-
-        return True, "✅ Database Connected"
-
+            result = conn.execute(text(sql))
+            rows = [dict(r._mapping) for r in result]
+            
+        return rows
+        
     except Exception as e:
-
-        return False, str(e)
+        print(f"Suspicious Vehicles Error: {e}")
+        return []

packages.txt

@@ -0,0 +1,6 @@
+libglib2.0-0
+libsm6
+libxext6
+libxrender-dev
+ffmpeg
+libgomp1

requirements.txt

@@ -1,17 +1,32 @@
 ultralytics==8.4.46
+
 opencv-python-headless==4.8.1.78
+
 numpy==1.26.4
 
 paddleocr==2.7.0.3
 paddlepaddle==2.6.2
 
 transformers==4.40.0
+
 torch==2.1.2
+torchvision==0.16.2
+
 Pillow==10.1.0
 
-sqlalchemy
-psycopg2-binary
-python-dotenv
-pandas
-gradio
-huggingface_hub
+sqlalchemy==2.0.30
+psycopg2-binary==2.9.9
+
+python-dotenv==1.0.1
+
+pandas==2.2.2
+
+gradio==4.44.1
+
+huggingface_hub==0.23.0
+
+accelerate==0.30.1
+
+sentencepiece==0.2.0
+
+scipy==1.13.1