# 🎯 Production NLP Engine - Query Examples & Integration Guide

## 📋 Table of Contents

1. [Getting Started](#getting-started)
2. [Query Examples by Category](#query-examples-by-category)
3. [Integration with Gradio](#integration-with-gradio)
4. [Advanced API Usage](#advanced-api-usage)
5. [Troubleshooting](#troubleshooting)

---

## 🚀 Getting Started

### Basic Setup

No configuration needed! The engine works out of the box. Just use `ask_llm(query)`:

```python
from database import ask_llm, run_query

# Method 1: Get SQL only
sql = ask_llm("show buses in adyar")
print(sql)  # SELECT ... WHERE ...

# Method 2: Execute and get results
result = run_query("show buses in adyar")
print(result["count"])     # Number of records
print(result["result"])    # List of records
```

---

## 📊 Query Examples by Category

### 1️⃣ BASIC FILTERING

#### State Filter
```
"show TN vehicles"
"show Tamil Nadu cars"
"show Karnataka buses"

Generated SQL:
SELECT * FROM vehicle_logs
WHERE state='TN'
ORDER BY timestamp DESC LIMIT 100;
```

#### Location Filter
```
"show vehicles in adyar"
"show vehicles in besant nagar"
"show vehicles in t nagar"

Generated SQL:
SELECT * FROM vehicle_logs
WHERE LOWER(location) LIKE '%adyar%'
ORDER BY timestamp DESC LIMIT 100;
```

#### Vehicle Type Filter
```
"show buses"
"show cars"
"show trucks"
"show motorcycles"

Generated SQL:
SELECT * FROM vehicle_logs
WHERE LOWER(vehicle_type) LIKE '%bus%'
ORDER BY timestamp DESC LIMIT 100;
```

---

### 2️⃣ MULTI-FILTER COMBINATIONS

#### State + Vehicle Type
```
"show TN buses"
"show TN cars in adyar"
"show Kerala trucks"

Generated SQL:
SELECT * FROM vehicle_logs
WHERE state='TN' AND LOWER(vehicle_type) LIKE '%bus%'
ORDER BY timestamp DESC LIMIT 100;
```

#### State + Location + Vehicle Type
```
"show TN buses in adyar"
"show Karnataka cars in bangalore"

Generated SQL:
SELECT * FROM vehicle_logs
WHERE state='TN'
  AND LOWER(location) LIKE '%adyar%'
  AND LOWER(vehicle_type) LIKE '%bus%'
ORDER BY timestamp DESC LIMIT 100;
```

---

### 3️⃣ DATE RANGE QUERIES

#### Simple Date Range
```
"show buses from 01-05-2026 to 10-05-2026"
"show vehicles between 2026-05-01 and 2026-05-10"

Generated SQL:
SELECT * FROM vehicle_logs
WHERE LOWER(vehicle_type) LIKE '%bus%'
  AND date BETWEEN '2026-05-01' AND '2026-05-10'
ORDER BY timestamp DESC LIMIT 100;
```

#### Date Range + State + Location
```
"show TN buses in adyar from 01-05-2026 to 10-05-2026"

Generated SQL:
SELECT * FROM vehicle_logs
WHERE state='TN'
  AND LOWER(location) LIKE '%adyar%'
  AND LOWER(vehicle_type) LIKE '%bus%'
  AND date BETWEEN '2026-05-01' AND '2026-05-10'
ORDER BY timestamp DESC LIMIT 100;
```

---

### 4️⃣ TIME RANGE QUERIES

#### After/Before Time
```
"show vehicles after 8 PM"
"show buses before 6 AM"
"show cars after 5 PM"

Generated SQL:
SELECT * FROM vehicle_logs
WHERE hour BETWEEN 20 AND 23
ORDER BY timestamp DESC LIMIT 100;

(20 = 8 PM, 23 = 11 PM)
```

#### Between Time Range
```
"show vehicles between 6 PM and 9 PM"
"show buses between 2 AM and 5 AM"

Generated SQL:
SELECT * FROM vehicle_logs
WHERE hour BETWEEN 18 AND 21
ORDER BY timestamp DESC LIMIT 100;
```

#### Time Period Keywords
```
"show vehicles in the morning"
"show buses during evening"
"show cars at night"
"show trucks during peak hours"
"show vehicles at midnight"

Mappings:
- morning: 5-12 (5 AM to 12 PM)
- afternoon: 12-17 (12 PM to 5 PM)
- evening: 17-21 (5 PM to 9 PM)
- night: 21-24 (9 PM to 12 AM)
- peak/rush: 8-10 (8 AM to 10 AM)
- midnight: 0-4 (12 AM to 4 AM)
```

#### Complex Time Range
```
"show TN buses in adyar from 01-05-2026 to 10-05-2026 after 8 PM"

Generated SQL:
SELECT * FROM vehicle_logs
WHERE state='TN'
  AND LOWER(location) LIKE '%adyar%'
  AND LOWER(vehicle_type) LIKE '%bus%'
  AND date BETWEEN '2026-05-01' AND '2026-05-10'
  AND hour BETWEEN 20 AND 23
ORDER BY timestamp DESC LIMIT 100;
```

---

### 5️⃣ DAY-BASED QUERIES

#### Specific Day
```
"show buses on monday"
"show vehicles on friday"
"show cars on sunday"

Generated SQL:
SELECT * FROM vehicle_logs
WHERE LOWER(vehicle_type) LIKE '%bus%'
  AND day='Monday'
ORDER BY timestamp DESC LIMIT 100;
```

#### Weekend/Weekday
```
"show vehicles on weekend"
"show buses on weekday"

Generated SQL:
SELECT * FROM vehicle_logs
WHERE (day='Saturday' OR day='Sunday')
ORDER BY timestamp DESC LIMIT 100;
```

#### Combined with Other Filters
```
"show TN buses in adyar on monday"
"show cars on weekend"

Generated SQL:
SELECT * FROM vehicle_logs
WHERE state='TN'
  AND LOWER(location) LIKE '%adyar%'
  AND LOWER(vehicle_type) LIKE '%bus%'
  AND day='Monday'
ORDER BY timestamp DESC LIMIT 100;
```

---

### 6️⃣ TRACKING & ROUTE HISTORY

#### Track by Plate
```
"track TN63MB3157"
"show route history for TN10AB1234"

Generated SQL:
SELECT timestamp, plate, state, vehicle_type, location, camera_id, date, hour, day
FROM vehicle_logs
WHERE plate='TN63MB3157'
ORDER BY timestamp DESC LIMIT 100;
```

#### Track with Location Filter
```
"track TN63MB3157 in adyar"
"track vehicle TN10AB1234 in velachery"

Generated SQL:
SELECT timestamp, plate, state, vehicle_type, location, camera_id, date, hour, day
FROM vehicle_logs
WHERE plate='TN63MB3157'
  AND LOWER(location) LIKE '%adyar%'
ORDER BY timestamp DESC LIMIT 100;
```

---

### 7️⃣ COUNT & AGGREGATION QUERIES

#### Simple Count
```
"count buses"
"how many cars are there"
"total number of vehicles"

Generated SQL:
SELECT COUNT(*) as total
FROM vehicle_logs
WHERE LOWER(vehicle_type) LIKE '%bus%';
```

#### Count with Filters
```
"count TN buses in adyar"
"how many vehicles detected on monday"

Generated SQL:
SELECT COUNT(*) as total
FROM vehicle_logs
WHERE state='TN'
  AND LOWER(location) LIKE '%adyar%'
  AND LOWER(vehicle_type) LIKE '%bus%';
```

#### Count by Group
```
"count vehicles from each state"

Generated SQL:
SELECT state, COUNT(*) as count
FROM vehicle_logs
GROUP BY state
ORDER BY count DESC;
```

---

### 8️⃣ ANALYTICS & AGGREGATION

#### Top Vehicles
```
"show top vehicles"
"top 10 most detected vehicles"
"leading vehicles"

Generated SQL:
SELECT plate, state, COUNT(*) as detections
FROM vehicle_logs
GROUP BY plate, state
ORDER BY detections DESC
LIMIT 20;
```

#### Hourly Traffic
```
"show hourly traffic"
"traffic by hour"
"hourly distribution"

Generated SQL:
SELECT hour, COUNT(*) as traffic
FROM vehicle_logs
GROUP BY hour
ORDER BY hour;
```

#### Traffic by Location
```
"show traffic density by location"
"vehicles by location"

Generated SQL:
SELECT location, COUNT(*) as count
FROM vehicle_logs
WHERE location IS NOT NULL
GROUP BY location
ORDER BY count DESC LIMIT 20;
```

#### Peak Hours
```
"show peak traffic hours"
"busiest hours"

Generated SQL:
SELECT hour, COUNT(*) as traffic_count
FROM vehicle_logs
GROUP BY hour
ORDER BY traffic_count DESC
LIMIT 10;
```

---

### 9️⃣ SUSPICIOUS VEHICLE DETECTION

#### Basic Suspicious
```
"show suspicious vehicles"
"repeated vehicles"
"vehicles detected multiple times"

Generated 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;
```

#### Multi-Location Detection
```
"show vehicles detected across multiple locations"
"vehicles in more than 2 locations"

Generated 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(DISTINCT location) > 2
ORDER BY locations DESC
LIMIT 20;
```

---

### 🔟 ADVANCED QUERIES

#### Confidence Threshold
```
"show high confidence detections"
"vehicles with 0.9 confidence"

Generated SQL:
SELECT * FROM vehicle_logs
WHERE vehicle_conf >= 0.9
ORDER BY timestamp DESC
LIMIT 100;
```

#### Complex Combined Query
```
"show TN high-confidence buses detected in multiple locations from 01-05-2026 to 10-05-2026 between 6 PM and 9 PM"

Generated SQL:
SELECT * FROM vehicle_logs
WHERE state='TN'
  AND LOWER(vehicle_type) LIKE '%bus%'
  AND vehicle_conf >= 0.9
  AND date BETWEEN '2026-05-01' AND '2026-05-10'
  AND hour BETWEEN 18 AND 21
  AND location IS NOT NULL
ORDER BY timestamp DESC
LIMIT 100;
```

---

## 🎨 Integration with Gradio

### In app.py - NLP Query Tab

```python
import gradio as gr
from database import ask_llm, run_query

def query_database(message, history):
    """NLP-to-SQL query handler for Gradio chatbot"""
    
    try:
        # Generate SQL from natural language
        sql = ask_llm(message)
        
        # Execute query
        result = run_query(message)
        
        # Format response
        if result.get("error"):
            response = f"❌ Error: {result['error']}"
        else:
            count = result.get("count", 0)
            if count == 0:
                response = f"No records found for: {message}"
            else:
                response = f"✅ Found {count} records\n\nGenerated SQL:\n{result.get('sql', '')}"
                
                # Show first few results
                if result.get("result"):
                    response += f"\n\nFirst record:\n{str(result['result'][0])}"
        
        # Add to chat history
        history = history + [[message, response]]
        
        return history
    
    except Exception as e:
        response = f"❌ Query error: {str(e)}"
        history = history + [[message, response]]
        return history

# Create NLP Query tab
with gr.TabItem("🔍 NLP Database Query"):
    chatbot = gr.Chatbot(
        label="Ask about vehicles",
        height=400
    )
    
    msg = gr.Textbox(
        label="Query (natural language)",
        placeholder="e.g., 'show TN buses in adyar from 01-05-2026 to 10-05-2026'",
        lines=2
    )
    
    msg.submit(query_database, [msg, chatbot], [chatbot])
```

---

## 💻 Advanced API Usage

### Direct Function Calls (Beyond ask_llm)

```python
from database import (
    get_route_history,
    get_multi_location_detections,
    get_peak_traffic_hours,
    get_vehicle_density_by_location,
    get_high_confidence_detections,
    query_by_date_range,
    query_by_time_range
)

# 1. Get route history for specific vehicle
route = get_route_history(plate="TN63MB3157", limit=50)
for record in route:
    print(f"{record['timestamp']} - {record['location']}")

# 2. Find suspicious vehicles (multi-location)
suspicious = get_multi_location_detections(min_locations=3)
for vehicle in suspicious:
    print(f"{vehicle['plate']}: {vehicle['locations']} locations, {vehicle['detections']} detections")

# 3. Identify peak hours
peak_hours = get_peak_traffic_hours()
for hour_data in peak_hours:
    print(f"Hour {hour_data['hour']}: {hour_data['traffic_count']} vehicles")

# 4. Traffic density by location
density = get_vehicle_density_by_location()
for location_data in density:
    print(f"{location_data['location']}: {location_data['vehicle_count']} vehicles")

# 5. High confidence only
high_conf = get_high_confidence_detections(confidence_threshold=0.95)
for vehicle in high_conf:
    print(f"{vehicle['plate']}: {vehicle['avg_confidence']:.2%} confidence")

# 6. Date range query
date_range = query_by_date_range(
    start_date="2026-05-01",
    end_date="2026-05-10",
    state="TN",
    location="adyar"
)
print(f"Found {len(date_range)} vehicles in date range")

# 7. Time range query
time_range = query_by_time_range(
    start_hour=20,
    end_hour=23,
    location="adyar"
)
print(f"Found {len(time_range)} vehicles at night in adyar")
```

---

## 🐛 Troubleshooting

### Issue: Empty Results

**Problem**: Query returns no records

**Solutions**:
```python
# 1. Check database has data
health = health_check()
print(health)  # Should show record count

# 2. Try basic query
result = run_query("show vehicles")
print(result)  # Should return something

# 3. Check filters are specific enough
# "show buses" might return nothing if no buses exist
# Try: "show vehicles" first
```

### Issue: SQL Syntax Error

**Problem**: "Query timeout or error"

**Solutions**:
```python
# 1. Check the generated SQL
sql = ask_llm(your_query)
print(sql)  # Review the SQL

# 2. Use simpler query first
# Instead of: "show TN buses in adyar from X to Y after 8 PM with 0.9 confidence"
# Try: "show TN buses"

# 3. Try different date format
# Instead of: "01/05/2026"
# Try: "01-05-2026" or "2026-05-01"
```

### Issue: Date Parsing

**Problem**: Date range not recognized

**Solutions**:
```python
# Valid formats (all work):
- "2026-05-01"      # YYYY-MM-DD
- "01-05-2026"      # DD-MM-YYYY
- "01/05/2026"      # DD/MM/YYYY

# Also valid:
"from 01-05-2026 to 10-05-2026"
"between 2026-05-01 and 2026-05-10"
"from 01/05/2026 to 10/05/2026"

# Invalid (will not parse):
"from May 1 to May 10"
"from 2026-5-1 to 2026-5-10"  # Need zero-padding
```

### Issue: Time Not Recognized

**Problem**: "after 8 PM" not working

**Solutions**:
```python
# Valid formats:
"after 8 PM"
"after 20:00"
"after 20"
"between 8 PM and 11 PM"
"morning"
"afternoon"
"evening"
"night"
"peak hours"

# Invalid:
"after 8:30 PM 45 seconds"  # Too specific
"after 20:30:45"  # Includes seconds

# Use time period keywords instead:
"show vehicles in the morning"  # 5 AM - 12 PM
"show vehicles in the evening"  # 5 PM - 9 PM
```

### Issue: Location Not Found

**Problem**: Location filter ignored

**Solutions**:
```python
# Try these location variants:
adyar → adyar
besant nagar → besant, besant nagar, besantnagar
t nagar → t nagar, tnagar, t-nagar
anna nagar → anna, anna nagar, annanagar
velachery → velachery
guindy → guindy
thiruvanmiyur → thiruvanmiyur
mylapore → mylapore
koyambedu → koyambedu
nungambakkam → nungambakkam, nungam
kotturpuram → kotturpuram

# If location still not found:
# 1. Check spelling
# 2. Try partial name: "show vehicles in adya" → should match "adyar"
# 3. Try without location filter
```

---

## 📝 Complete Test Script

```python
from database import ask_llm, run_query

test_queries = [
    # Basic
    "show TN vehicles",
    "show buses",
    "show vehicles in adyar",
    
    # Multi-filter
    "show TN buses in adyar",
    "show cars in velachery",
    
    # Date range
    "show vehicles from 01-05-2026 to 10-05-2026",
    "show buses between 2026-05-01 and 2026-05-10",
    
    # Time range
    "show vehicles after 8 PM",
    "show buses between 6 PM and 9 PM",
    "show vehicles in the morning",
    
    # Combined
    "show TN buses in adyar from 01-05-2026 to 10-05-2026 after 8 PM",
    
    # Tracking
    "track TN63MB3157",
    "track TN63MB3157 in adyar",
    
    # Count
    "count buses",
    "count TN vehicles in adyar",
    
    # Analytics
    "show top vehicles",
    "show hourly traffic",
    "show traffic by location",
    
    # Suspicious
    "show suspicious vehicles",
    "vehicles in multiple locations",
    
    # Advanced
    "show high confidence detections",
]

for query in test_queries:
    print(f"\n{'='*60}")
    print(f"📝 Query: {query}")
    print('='*60)
    
    sql = ask_llm(query)
    print(f"\n📋 SQL:\n{sql}")
    
    result = run_query(query)
    print(f"\n✅ Results: {result['count']} records found")
    if result.get("error"):
        print(f"❌ Error: {result['error']}")
```

---

## ✨ Summary

The production NLP engine supports:

✅ 100+ natural language query variations  
✅ Simultaneous extraction of 10 filter dimensions  
✅ Date range queries  
✅ Time range queries  
✅ Advanced analytics and aggregations  
✅ Suspicious vehicle detection  
✅ Multi-location tracking  
✅ Confidence-based filtering  
✅ 30+ direct API functions  
✅ Timeout protection  
✅ SQL safety  

**All queries work out of the box!**