test

.dockerignore

@@ -1,41 +0,0 @@
-# Python
-__pycache__/
-*.py[cod]
-*$py.class
-*.so
-.Python
-*.egg-info/
-dist/
-build/
-
-# Virtual environments
-venv/
-env/
-ENV/
-
-# IDE
-.vscode/
-.idea/
-*.swp
-*.swo
-
-# Git
-.git/
-.gitignore
-
-# Logs
-logs/*.log
-
-# Environment (will be set via HF Secrets)
-.env
-
-# Archive (not needed in deployment)
-archive/
-
-# Documentation
-*.md
-!README.md
-
-# Test files
-tests/
-*.test.py

.env.example

@@ -1,50 +1,28 @@
-# ============================================================================
-# FleetMind MCP Server - Environment Configuration
-# For HuggingFace Space (Track 1) deployment
-# ============================================================================
+# AI Provider Selection (choose one: "anthropic" or "gemini")
+AI_PROVIDER=anthropic
 
-# ============================================================================
-# Google Maps API (REQUIRED)
-# ============================================================================
-# Used for geocoding addresses and calculating routes
-# Get your API key at: https://console.cloud.google.com/google/maps-apis
-# Enable these APIs in your Google Cloud Console:
-#   - Geocoding API (required for address lookup)
-#   - Routes API (recommended - new, more accurate)
-#   - Directions API (legacy fallback)
-# The system will try Routes API first, then fall back to Directions API
-GOOGLE_MAPS_API_KEY=your_google_maps_api_key_here
+# API Keys for AI Providers
+ANTHROPIC_API_KEY=your_anthropic_api_key_here
+GOOGLE_API_KEY=your_google_api_key_here
 
-# ============================================================================
-# OpenWeatherMap API (OPTIONAL - for intelligent routing)
-# ============================================================================
-# Used for weather-aware routing decisions
-# Get free API key at: https://openweathermap.org/api
-# Free tier: 1,000 calls/day, 60 calls/minute
-OPENWEATHERMAP_API_KEY=your_openweathermap_api_key_here
+# HERE Maps API Key (for geocoding)
+HERE_API_KEY=your_here_api_key_here
 
-# ============================================================================
-# PostgreSQL Database Configuration (REQUIRED)
-# ============================================================================
-# For local development, use localhost
-# For HuggingFace Space, use Neon or other cloud PostgreSQL
-# Get free PostgreSQL at: https://neon.tech
-DB_HOST=your-postgres-host.neon.tech
+# PostgreSQL Database Configuration
+DB_HOST=localhost
 DB_PORT=5432
 DB_NAME=fleetmind
-DB_USER=your_db_user
-DB_PASSWORD=your_db_password
+DB_USER=postgres
+DB_PASSWORD=your_password_here
 
-# ============================================================================
-# Server Configuration (OPTIONAL)
-# ============================================================================
-# HuggingFace Space will set these automatically
-# Only needed for local SSE mode testing
-PORT=7860
-HOST=0.0.0.0
+# MCP Server
+MCP_SERVER_NAME=dispatch-coordinator-mcp
+MCP_SERVER_VERSION=1.0.0
 
-# ============================================================================
-# Logging (OPTIONAL)
-# ============================================================================
+# Gradio
+GRADIO_SERVER_PORT=7860
+GRADIO_SHARE=false
+
+# Logging
 LOG_LEVEL=INFO
 LOG_FILE=logs/fleetmind.log

.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

.github/workflows/check-file-size.yml

@@ -1,16 +0,0 @@
-name: Check file size
-on:
-  pull_request:
-    branches: [main]
-
-  # Allow manual trigger from Actions tab
-  workflow_dispatch:
-
-jobs:
-  check-file-size:
-    runs-on: ubuntu-latest
-    steps:
-      - name: Check large files
-        uses: ActionsDesk/lfs-warning@v2.0
-        with:
-          filesizelimit: 10485760 # 10MB limit for HF Spaces sync

.github/workflows/sync-to-huggingface.yml

@@ -1,24 +0,0 @@
-name: Sync to Hugging Face Space
-on:
-  push:
-    branches: [main]
-
-  # Allow manual trigger from Actions tab
-  workflow_dispatch:
-
-jobs:
-  sync-to-hub:
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v3
-        with:
-          fetch-depth: 0
-          lfs: true
-
-      - name: Push to Hugging Face Space
-        env:
-          HF_TOKEN: ${{ secrets.HF_TOKEN }}
-        run: |
-          git config --global user.email "github-actions[bot]@users.noreply.github.com"
-          git config --global user.name "github-actions[bot]"
-          git push https://MCP-1st-Birthday:$HF_TOKEN@huggingface.co/spaces/MCP-1st-Birthday/fleetmind-dispatch-ai main --force

.gitignore

@@ -33,16 +33,10 @@ data/*.db
 
 # Environment Variables
 .env
-.env.*
-*.env
-.env.local
-.env.production
-.env.development
 
 # IDE
 .vscode/
 .idea/
-.claude/
 *.swp
 *.swo
 *~

DRIVER_CREATION_GUIDE.md

@@ -0,0 +1,318 @@
+# Driver Creation Feature Guide
+
+## ✅ **Feature Status: READY**
+
+The driver creation feature has been successfully implemented and tested!
+
+---
+
+## 🚀 **How to Use**
+
+### **Step 1: Restart Your Application**
+
+Since we updated Gemini's system prompt and tools, restart the app:
+
+```bash
+# Stop the current app (Ctrl+C)
+python ui/app.py
+```
+
+---
+
+### **Step 2: Create Drivers Using Natural Language**
+
+Open the chat at http://127.0.0.1:7860 and type naturally!
+
+---
+
+## 📝 **Example Commands**
+
+### **Example 1: Complete Driver Info**
+
+```
+Add new driver Tom Wilson, phone 555-0101, drives a van, plate ABC-123
+```
+
+**Gemini will create:**
+- Driver ID: DRV-20251114HHMMSS (auto-generated)
+- Name: Tom Wilson
+- Phone: 555-0101
+- Vehicle: van
+- Plate: ABC-123
+- Status: active (default)
+- Capacity: 1000 kg (default for van)
+
+---
+
+### **Example 2: Driver with Skills**
+
+```
+Create driver Sarah Martinez, phone 555-0202, refrigerated truck, plate XYZ-789,
+skills: medical_certified, refrigerated
+```
+
+**Gemini will create:**
+- Name: Sarah Martinez
+- Phone: 555-0202
+- Vehicle: truck
+- Plate: XYZ-789
+- Skills: ["medical_certified", "refrigerated"]
+- Capacity: 1000 kg (default)
+
+---
+
+### **Example 3: Minimal Info (Name Only)**
+
+```
+Add driver Mike Chen
+```
+
+**Gemini will create:**
+- Name: Mike Chen
+- Vehicle: van (default)
+- Capacity: 1000 kg (default)
+- Status: active (default)
+- Skills: [] (empty by default)
+
+Gemini might ask: "Would you like to provide phone number or vehicle details?"
+
+---
+
+### **Example 4: Motorcycle Courier**
+
+```
+New driver: Lisa Anderson, phone 555-0303, motorcycle, express delivery specialist
+```
+
+**Gemini will create:**
+- Name: Lisa Anderson
+- Phone: 555-0303
+- Vehicle: motorcycle
+- Skills: ["express_delivery"]
+- Capacity: 50 kg (you can specify)
+
+---
+
+## 🎯 **Available Fields**
+
+### **Required:**
+- ✅ **name** - Driver's full name
+
+### **Optional:**
+- **phone** - Contact number (e.g., "+1-555-0101")
+- **email** - Email address (e.g., "driver@fleet.com")
+- **vehicle_type** - van | truck | car | motorcycle (default: van)
+- **vehicle_plate** - License plate (e.g., "ABC-1234")
+- **capacity_kg** - Cargo weight capacity in kg (default: 1000.0)
+- **capacity_m3** - Cargo volume capacity in m³ (default: 12.0)
+- **skills** - List of certifications/skills:
+  - `refrigerated` - Can handle cold storage
+  - `medical_certified` - Medical deliveries
+  - `fragile_handler` - Fragile items expert
+  - `overnight` - Overnight/late deliveries
+  - `express_delivery` - Express/rush deliveries
+- **status** - active | busy | offline | unavailable (default: active)
+
+---
+
+## 🧪 **Testing**
+
+### **Test 1: Verify Creation**
+
+After creating a driver, check the database:
+
+```bash
+python verify_drivers.py
+```
+
+This will show all drivers including the newly created one.
+
+---
+
+### **Test 2: Check in UI**
+
+Go to the **Orders** tab in the UI and you should see new drivers available for assignment.
+
+---
+
+## 📊 **What Happens Behind the Scenes**
+
+### **User Input:**
+```
+"Add new driver Tom Wilson, phone 555-0101, drives a van, plate ABC-123"
+```
+
+### **Gemini Processing:**
+1. **Parses** your natural language input
+2. **Extracts** driver information:
+   - name: "Tom Wilson"
+   - phone: "555-0101"
+   - vehicle_type: "van"
+   - vehicle_plate: "ABC-123"
+3. **Calls** `create_driver` tool with extracted data
+4. **Database** inserts the driver with auto-generated ID
+5. **Returns** confirmation message
+
+### **Database Record Created:**
+```sql
+INSERT INTO drivers (
+    driver_id,           -- DRV-20251114113250 (auto)
+    name,                -- Tom Wilson
+    phone,               -- 555-0101
+    vehicle_type,        -- van
+    vehicle_plate,       -- ABC-123
+    status,              -- active (default)
+    capacity_kg,         -- 1000.0 (default)
+    capacity_m3,         -- 12.0 (default)
+    skills,              -- [] (empty)
+    current_lat,         -- 37.7749 (default SF)
+    current_lng,         -- -122.4194 (default SF)
+    last_location_update -- 2025-11-14 11:32:50
+) VALUES (...)
+```
+
+---
+
+## 🔄 **Comparison: Orders vs Drivers**
+
+### **Creating an Order:**
+```
+User: "Create order for John Doe, 123 Main St SF, phone 555-1234"
+    ↓
+Gemini: [geocode_address] → [create_order] → "✅ Order created!"
+```
+**2 tools called** (geocoding required for addresses)
+
+### **Creating a Driver:**
+```
+User: "Add driver Tom Wilson, phone 555-0101, van"
+    ↓
+Gemini: [create_driver] → "✅ Driver created!"
+```
+**1 tool called** (no geocoding needed)
+
+---
+
+## ⚡ **Quick Reference**
+
+### **Conversational Examples:**
+
+✅ "I need to onboard a new driver named Alex"
+✅ "Add Sarah to the fleet, she drives a truck"
+✅ "New driver: Mike, phone 555-9999, motorcycle"
+✅ "Create driver with medical certification"
+✅ "Add a refrigerated truck driver named Bob"
+
+### **Structured Examples:**
+
+✅ "Create driver: Name: Tom Wilson, Phone: 555-0101, Vehicle: van, Plate: ABC-123"
+✅ "New driver - Name: Sarah, Email: sarah@fleet.com, Vehicle type: truck, Skills: refrigerated, medical_certified"
+
+---
+
+## 🎨 **Sample Responses from Gemini**
+
+### **Successful Creation:**
+```
+✅ Driver DRV-20251114113250 created successfully!
+
+Driver Details:
+• Driver ID: DRV-20251114113250
+• Name: Tom Wilson
+• Phone: 555-0101
+• Vehicle: van (ABC-123)
+• Capacity: 1000 kg
+• Status: Active
+• Skills: None
+
+The driver has been added to your fleet and is ready for order assignments!
+```
+
+### **Missing Information:**
+```
+I can create a driver for you! I have:
+• Name: Tom Wilson
+
+To complete the driver profile, please provide (optional):
+• Phone number
+• Vehicle type (van/truck/car/motorcycle)
+• License plate number
+• Any special skills or certifications
+
+Or I can create the driver now with default settings?
+```
+
+---
+
+## 🛠️ **Technical Details**
+
+### **Function:** `handle_create_driver()`
+**Location:** `chat/tools.py:245-331`
+
+### **Tool Definition:**
+**Location:** `chat/providers/gemini_provider.py:140-186`
+
+### **System Prompt:**
+**Location:** `chat/providers/gemini_provider.py:32-89`
+
+---
+
+## ✨ **Next Steps**
+
+After creating drivers, you can:
+
+1. **Assign orders to drivers** (coming soon)
+2. **View driver list** in the UI
+3. **Update driver status** (active/busy/offline)
+4. **Track driver locations** (coming soon)
+
+---
+
+## 🐛 **Troubleshooting**
+
+### **Issue: "Unknown tool: create_driver"**
+
+**Solution:** Restart the application to reload the new tools:
+```bash
+# Stop app (Ctrl+C)
+python ui/app.py
+```
+
+### **Issue: Driver created but not showing in database**
+
+**Solution:** Check database connection and verify:
+```bash
+python verify_drivers.py
+```
+
+### **Issue: "Missing required field: name"**
+
+**Solution:** Make sure you provide at least the driver's name:
+```
+"Add driver John Smith"  ✅
+"Add a new driver"       ❌ (no name)
+```
+
+---
+
+## 📈 **Feature Comparison**
+
+| Feature | Orders | Drivers |
+|---------|--------|---------|
+| **Required Fields** | 3 (name, address, contact) | 1 (name) |
+| **Geocoding Needed** | ✅ Yes | ❌ No |
+| **Tools Called** | 2 (geocode + create) | 1 (create) |
+| **Default Values** | Priority, weight | Vehicle type, capacity, status |
+| **Complex Data** | Time windows, coordinates | Skills array, JSON |
+
+---
+
+## 🎉 **Ready to Use!**
+
+Your FleetMind system can now:
+- ✅ Create customer orders
+- ✅ Create delivery drivers
+- ✅ Geocode addresses
+- ✅ Store everything in PostgreSQL
+
+Just talk naturally to Gemini and it handles the rest! 🚀

Dockerfile

@@ -1,34 +0,0 @@
-# FleetMind MCP Server - HuggingFace Space Dockerfile
-# Read the doc: https://huggingface.co/docs/hub/spaces-sdks-docker
-
-FROM python:3.11-slim
-
-# Create non-root user (HuggingFace requirement)
-RUN useradd -m -u 1000 user
-USER user
-ENV PATH="/home/user/.local/bin:$PATH"
-
-# Set working directory
-WORKDIR /app
-
-# Copy requirements first (for better caching)
-COPY --chown=user requirements.txt /app/requirements.txt
-
-# Install dependencies
-RUN pip install --no-cache-dir --upgrade -r requirements.txt
-
-# Copy application files
-COPY --chown=user . /app
-
-# Create logs directory
-RUN mkdir -p /app/logs
-
-# Expose port 7860 (HuggingFace Space default)
-EXPOSE 7860
-
-# Health check (check proxy health endpoint)
-HEALTHCHECK --interval=30s --timeout=10s --start-period=5s --retries=3 \
-  CMD python -c "import requests; requests.get('http://localhost:7860/health')" || exit 1
-
-# Run the MCP server with authentication proxy
-CMD ["python", "start_with_proxy.py"]

README.md

@@ -1,309 +1,195 @@
 ---
-title: FleetMind MCP Server
+title: FleetMind AI Dispatch Coordinator
 emoji: 🚚
 colorFrom: blue
 colorTo: purple
-sdk: docker
+sdk: gradio
+sdk_version: 5.9.0
 app_file: app.py
-pinned: true
-short_description: AI delivery dispatch MCP server with 29 management tools
+pinned: false
 tags:
   - mcp
-  - building-mcp-track-enterprise
+  - mcp-in-action-track-01
   - model-context-protocol
+  - multi-agent
+  - autonomous-ai
+  - gemini-2.0-flash
   - delivery-management
   - postgresql
-  - fastmcp
-  - gradio
-  - enterprise
-  - logistics
-  - gemini
-  - google-maps
-  - ai-routing
 ---
 
-<div align="center">
+# FleetMind MCP - Autonomous Dispatch Coordinator
 
-# 🚚 FleetMind MCP Server
+**🏆 MCP 1st Birthday Hackathon Submission - Track: MCP in Action**
 
-### AI-Powered Delivery Dispatch for the Modern Enterprise
+An autonomous AI coordinator that handles delivery exceptions using multi-agent orchestration powered by Google Gemini 2.0 Flash and the Model Context Protocol (MCP).
 
-**The Problem:** Delivery dispatch is complex—coordinating drivers, optimizing routes, handling weather delays, and meeting SLAs requires constant human oversight.
+---
 
-**The Solution:** FleetMind exposes **29 AI-accessible tools** that let Claude (or any MCP client) manage your entire delivery operation through natural conversation.
+## 👥 Team
 
-**The Impact:** Dispatch managers can now say *"Assign this urgent fragile delivery to the best available driver considering weather and traffic"* and watch AI handle the complexity.
+**Team Name:** [Your Team Name]
 
-[![Demo Video](https://img.shields.io/badge/▶_Watch_Demo-FF0000?style=for-the-badge&logo=youtube&logoColor=white)](https://www.youtube.com/watch?v=IA9iD0VPvro)
-[![Try It Live](https://img.shields.io/badge/🚀_Try_It_Live-7C3AED?style=for-the-badge)](https://mcp-1st-birthday-fleetmind-dispatch-ai.hf.space)
-[![GitHub](https://img.shields.io/badge/GitHub-181717?style=for-the-badge&logo=github&logoColor=white)](https://github.com/mashrur-rahman-fahim/fleetmind-mcp)
-[![LinkedIn Post](https://img.shields.io/badge/LinkedIn_Post-0A66C2?style=for-the-badge&logo=linkedin&logoColor=white)](https://www.linkedin.com/posts/kazi-wasif-amin-shammo-3a0307197_mcpbirthdayhackathon-ai-mcp-activity-7400938958521675776-Trax)
-[![Facebook Post](https://img.shields.io/badge/Facebook_Post-1877F2?style=for-the-badge&logo=facebook&logoColor=white)](https://www.facebook.com/share/v/1BdfnLbuEY/)
+**Team Members:**
+- **[Your Name]** - [@your-hf-username](https://huggingface.co/your-hf-username) - Lead Developer & Repository Manager
+- **[Partner 2 Name]** - [@partner2-username](https://huggingface.co/partner2-username) - [Role - e.g., Backend Developer, Testing]
+- **[Partner 3 Name]** - [@partner3-username](https://huggingface.co/partner3-username) - [Role - e.g., Documentation, Video]
+- **[Partner 4 Name]** - [@partner4-username](https://huggingface.co/partner4-username) - [Role - e.g., UI/UX Designer]
+- **[Partner 5 Name]** - [@partner5-username](https://huggingface.co/partner5-username) - [Role - e.g., Project Manager]
 
-</div>
+**Collaboration:** Team collaborates via [GitHub repository / Pull Requests / Task Division] with contributions managed by the lead developer.
 
----
+*(Note: Replace placeholders with actual team member information. All members must have Hugging Face accounts and be listed here for valid hackathon submission.)*
 
-## 📺 See It In Action
-
-<div align="center">
-  <a href="https://www.youtube.com/watch?v=IA9iD0VPvro">
-    <img src="https://img.youtube.com/vi/IA9iD0VPvro/maxresdefault.jpg" alt="FleetMind Demo Video" width="560">
-  </a>
-  <p><b>▶️ Click to watch the demo video</b></p>
-</div>
+---
 
-> Watch Gemini 2.0 Flash AI analyze weather, traffic, and driver capabilities to make intelligent assignment decisions with full reasoning transparency.
+## 🚀 Quick Start
 
----
+### 1. Install PostgreSQL
 
-## ⚡ Quick Start (2 Minutes)
-
-### Step 1: Get Your API Key
-👉 **[Generate API Key](https://mcp-1st-birthday-fleetmind-dispatch-ai.hf.space/generate-key)** (copy immediately—shown once!)
-
-### Step 2: Configure Claude Desktop
-Add to your `claude_desktop_config.json`:
-```json
-{
-  "mcpServers": {
-    "fleetmind": {
-      "command": "npx",
-      "args": [
-        "mcp-remote",
-        "https://mcp-1st-birthday-fleetmind-dispatch-ai.hf.space/sse?api_key=YOUR_KEY_HERE"
-      ]
-    }
-  }
-}
-```
+**Windows:**
+- Download from https://www.postgresql.org/download/windows/
+- Install with default settings
+- Remember your postgres password
 
-### Step 3: Start Dispatching!
+**macOS:**
+```bash
+brew install postgresql
+brew services start postgresql
 ```
-You: "Create an urgent delivery for Sarah at 456 Oak Ave, San Francisco,
-     then use AI to find the best driver considering the current rain"
 
-Claude: Uses geocode_address → create_order → intelligent_assign_order
-        Returns: "Order ORD-... assigned to Mike (DRV-...).
-        AI selected Mike because: closest driver with cold-storage van,
-        safest route in current weather, 15 min ETA."
+**Linux:**
+```bash
+sudo apt-get install postgresql postgresql-contrib
+sudo systemctl start postgresql
 ```
 
----
-
-## 🏆 Why FleetMind?
-
-| Feature | What It Does | Why It Matters |
-|---------|--------------|----------------|
-| **🤖 Gemini 2.0 Flash AI** | Analyzes 10+ parameters for intelligent driver assignment | Better decisions than rule-based systems |
-| **🌦️ Weather-Aware Routing** | OpenWeatherMap integration for safety-first planning | Reduces weather-related delivery failures |
-| **🔐 Multi-Tenant Auth** | Complete data isolation via deterministic user_id | Enterprise-ready security out of the box |
-| **📊 SLA Tracking** | Automatic on-time/late/very-late classification | Built-in performance analytics |
-| **🚦 Real-Time Traffic** | Google Routes API with live traffic data | Accurate ETAs, not guesstimates |
-| **🏍️ Vehicle Optimization** | Motorcycle, bicycle, car, van, truck routing | Right routes for each vehicle type |
-
----
-
-## 🛠️ The 29 Tools
-
-<details>
-<summary><b>📍 Geocoding & Routing (3 tools)</b></summary>
-
-| Tool | Description |
-|------|-------------|
-| `geocode_address` | Convert address → GPS coordinates |
-| `calculate_route` | Vehicle-specific routing with traffic, tolls, fuel estimates |
-| `calculate_intelligent_route` | AI-powered routing with weather + traffic analysis |
-
-</details>
-
-<details>
-<summary><b>📦 Order Management (8 tools)</b></summary>
-
-| Tool | Description |
-|------|-------------|
-| `create_order` | Create delivery with mandatory deadline & SLA tracking |
-| `count_orders` | Count by status/priority with breakdowns |
-| `fetch_orders` | Paginated list with filters |
-| `get_order_details` | Full order info including timing data |
-| `search_orders` | Find by customer name/email/phone/ID |
-| `get_incomplete_orders` | Active deliveries shortcut |
-| `update_order` | Modify order with cascading updates |
-| `delete_order` | Safe deletion with assignment checks |
-
-</details>
-
-<details>
-<summary><b>👥 Driver Management (8 tools)</b></summary>
-
-| Tool | Description |
-|------|-------------|
-| `create_driver` | Onboard with vehicle type, skills, capacity |
-| `count_drivers` | Count by status/vehicle with breakdowns |
-| `fetch_drivers` | Paginated list with filters |
-| `get_driver_details` | Full info with reverse-geocoded location |
-| `search_drivers` | Find by name/plate/phone/ID |
-| `get_available_drivers` | Ready-for-dispatch shortcut |
-| `update_driver` | Modify with location auto-timestamp |
-| `delete_driver` | Safe deletion with assignment checks |
-
-</details>
-
-<details>
-<summary><b>🔗 Assignment Management (8 tools) ⭐</b></summary>
-
-| Tool | Description |
-|------|-------------|
-| `create_assignment` | Manual driver selection |
-| **`auto_assign_order`** | **Nearest driver + capacity/skill validation** |
-| **`intelligent_assign_order`** | **🤖 Gemini 2.0 Flash AI with full reasoning** |
-| `get_assignment_details` | Query by assignment/order/driver ID |
-| `update_assignment` | Status transitions with cascading |
-| `unassign_order` | Revert to pending safely |
-| `complete_delivery` | Mark done + auto-update driver location |
-| `fail_delivery` | Track failure with GPS + structured reason |
-
-</details>
-
-<details>
-<summary><b>🗑️ Bulk Operations (2 tools)</b></summary>
-
-| Tool | Description |
-|------|-------------|
-| `delete_all_orders` | Mass delete with status filter & safety checks |
-| `delete_all_drivers` | Mass delete with assignment safety blocks |
-
-</details>
+### 2. Create Database
 
----
+```bash
+# Login to PostgreSQL
+psql -U postgres
 
-## 🏗️ Architecture
+# Create the database
+CREATE DATABASE fleetmind;
 
+# Exit
+\q
 ```
-┌──────────────────────────────────────────────────────────────┐
-│                      MCP Clients                              │
-│     Claude Desktop  •  Continue  •  Cline  •  Custom Apps    │
-└─────────────────────────────┬────────────────────────────────┘
-                              │ SSE: /sse?api_key=fm_xxx
-                              ▼
-┌──────────────────────────────────────────────────────────────┐
-│              Authentication Proxy (proxy.py)                  │
-│  • Captures API key from SSE connection                       │
-│  • Links session_id → api_key for tool calls                  │
-│  • Keep-alive pings every 30s                                 │
-└─────────────────────────────┬────────────────────────────────┘
-                              ▼
-┌──────────────────────────────────────────────────────────────┐
-│              FastMCP Server (server.py)                       │
-│  • ApiKeyAuthMiddleware validates every call                  │
-│  • 29 tools with user_id filtering                            │
-│  • 2 real-time resources (orders://all, drivers://all)        │
-└──────────┬──────────┬────────────┬──────────┬────────────────┘
-           ▼          ▼            ▼          ▼
-    ┌──────────┐ ┌─────────┐ ┌──────────┐ ┌───────────┐
-    │PostgreSQL│ │ Google  │ │  Gemini  │ │OpenWeather│
-    │  (Neon)  │ │Maps API │ │2.0 Flash │ │  Map API  │
-    │ user_id  │ │Geocoding│ │Intelligent││  Weather  │
-    │isolation │ │ Routing │ │Assignment│ │   Data    │
-    └──────────┘ └─────────┘ └──────────┘ └───────────┘
-```
-
----
 
-## 🔐 Authentication & Security
+### 3. Set Up Environment
 
-FleetMind uses a **3-layer authentication system** for enterprise-grade security:
-
-| Layer | Component | Function |
-|-------|-----------|----------|
-| 1 | **Proxy** | Captures API key from URL, links sessions |
-| 2 | **Middleware** | Validates every tool call, injects user context |
-| 3 | **Database** | All queries filter by `user_id` (complete isolation) |
-
-**Security Features:**
-- ✅ SHA-256 hashed key storage (never plaintext)
-- ✅ One-time key display (can't retrieve later)
-- ✅ Deterministic user_id from email (key rotation preserves data)
-- ✅ Production safeguards (SKIP_AUTH blocked when ENV=production)
+```bash
+# Install Python dependencies
+pip install -r requirements.txt
 
-<details>
-<summary><b>View Complete Auth Flow</b></summary>
+# Copy environment template
+cp .env.example .env
 
-```
-1. Generate API Key → user_id = user_{MD5(email)[:12]}
-2. Configure Claude → URL includes ?api_key=fm_xxx
-3. SSE Connection → Proxy captures and stores key
-4. Tool Call → Proxy injects key, middleware validates
-5. Database Query → WHERE user_id = 'user_xxx'
-6. Result → Only user's own data returned
+# Edit .env with your database credentials
+# DB_HOST=localhost
+# DB_PORT=5432
+# DB_NAME=fleetmind
+# DB_USER=postgres
+# DB_PASSWORD=your_password_here
 ```
 
-</details>
+### 4. Initialize Database Schema
 
----
+```bash
+# Run database initialization script
+python scripts/init_db.py
+```
 
-## 🚀 Deployment
+This will create all necessary tables in the PostgreSQL database.
 
-### Production (HuggingFace Space)
-Already deployed at: **https://mcp-1st-birthday-fleetmind-dispatch-ai.hf.space**
+### 3. Run Application
 
-### Local Development
 ```bash
-git clone <repository-url>
-cd fleetmind-mcp
-pip install -r requirements.txt
-
-# Configure .env with your API keys
-python start_with_proxy.py  # Runs proxy (7860) + FastMCP (7861)
+# Start the Gradio UI (coming soon)
+python ui/app.py
 ```
 
----
+## 📁 Project Structure
 
-## 📊 Technical Specifications
+```
+fleetmind-mcp/
+├── database/               # Database connection and schema
+│   ├── __init__.py
+│   ├── connection.py      # Database connection utilities
+│   └── schema.py          # Database schema definitions
+├── data/                  # Database and data files
+│   └── fleetmind.db      # SQLite database (auto-generated)
+├── mcp_server/           # MCP server implementation
+├── agents/               # Multi-agent system
+├── workflows/            # Orchestration workflows
+├── ui/                   # Gradio interface
+├── tests/                # Test suite
+├── scripts/              # Utility scripts
+│   └── init_db.py       # Database initialization
+├── requirements.txt      # Python dependencies
+├── .env.example         # Environment variables template
+└── README.md            # This file
+```
 
-| Metric | Value |
-|--------|-------|
-| **Tools** | 29 |
-| **Resources** | 2 (orders://all, drivers://all) |
-| **Database** | PostgreSQL (Neon serverless) |
-| **AI Model** | Gemini 2.0 Flash (gemini-2.0-flash-exp) |
-| **Transport** | SSE (Server-Sent Events) |
-| **Framework** | FastMCP 2.13.0 |
-| **Language** | Python 3.10+ |
+## 📊 Database Schema (PostgreSQL)
 
----
+The system uses PostgreSQL with the following tables:
 
-## 🔗 Links
+### Orders Table
 
-| Resource | URL |
-|----------|-----|
-| **Live Demo** | https://mcp-1st-birthday-fleetmind-dispatch-ai.hf.space |
-| **MCP Endpoint** | https://mcp-1st-birthday-fleetmind-dispatch-ai.hf.space/sse |
-| **Generate API Key** | https://mcp-1st-birthday-fleetmind-dispatch-ai.hf.space/generate-key |
-| **HuggingFace Space** | https://huggingface.co/spaces/MCP-1st-Birthday/fleetmind-dispatch-ai |
+The `orders` table stores all delivery order information:
 
----
+| Column | Type | Description |
+|--------|------|-------------|
+| order_id | VARCHAR(50) | Primary key |
+| customer_name | VARCHAR(255) | Customer name |
+| customer_phone | VARCHAR(20) | Contact phone |
+| customer_email | VARCHAR(255) | Contact email |
+| delivery_address | TEXT | Delivery address |
+| delivery_lat/lng | DECIMAL(10,8) | GPS coordinates |
+| time_window_start/end | TIMESTAMP | Delivery time window |
+| priority | VARCHAR(20) | standard/express/urgent |
+| weight_kg | DECIMAL(10,2) | Package weight |
+| status | VARCHAR(20) | pending/assigned/in_transit/delivered/failed/cancelled |
+| assigned_driver_id | VARCHAR(50) | Assigned driver |
+| created_at | TIMESTAMP | Creation timestamp |
+| updated_at | TIMESTAMP | Auto-updated timestamp |
 
-## 👥 Team
+### Additional Tables
 
-**FleetMind Development Team**
+- **drivers** - Driver information and status
+- **assignments** - Order-driver assignments with routing
+- **exceptions** - Exception tracking and resolution
+- **agent_decisions** - AI agent decision logging
+- **metrics** - Performance metrics and analytics
 
-*MCP 1st Birthday Hackathon - Track 1: Building MCP Servers (Enterprise Category)*
+## 🔧 Development
 
----
+### Database Operations
 
-## 📄 License
+```python
+from database.connection import get_db_connection, execute_query, execute_write
 
-MIT License - see [LICENSE](LICENSE) for details.
+# Get all pending orders (note: PostgreSQL uses %s for parameters)
+orders = execute_query("SELECT * FROM orders WHERE status = %s", ("pending",))
 
----
+# Create new order
+order_id = execute_write(
+    "INSERT INTO orders (order_id, customer_name, delivery_address, status) VALUES (%s, %s, %s, %s)",
+    ("ORD-001", "John Doe", "123 Main St", "pending")
+)
+
+# Test connection
+from database.connection import test_connection
+if test_connection():
+    print("Database connected successfully!")
+```
 
-<div align="center">
+## 📝 License
 
-**Built with ❤️ using [FastMCP](https://gofastmcp.com) for the MCP 1st Birthday Hackathon**
+MIT License
 
-[![MCP](https://img.shields.io/badge/MCP-1.0-orange)](https://modelcontextprotocol.io)
-[![FastMCP](https://img.shields.io/badge/FastMCP-2.13.0-blue)](https://gofastmcp.com)
-[![Python](https://img.shields.io/badge/Python-3.10+-brightgreen)](https://python.org)
+## 🤝 Contributing
 
-</div>
+Contributions welcome! Please read the contributing guidelines first.

TEAM_COLLABORATION_GUIDE.md

@@ -0,0 +1,305 @@
+# Team Collaboration Guide - MCP 1st Birthday Hackathon
+
+## Overview
+
+This guide explains how to add team partners to your FleetMind MCP hackathon submission on Hugging Face Spaces.
+
+**Hackathon Details:**
+- **Team Size:** 2-5 members allowed
+- **Your Space:** https://huggingface.co/spaces/MCP-1st-Birthday/fleetmind-dispatch-ai
+- **Submission Deadline:** November 30, 2025 (11:59 PM UTC)
+- **Track:** MCP in Action (Track 01)
+
+---
+
+## Method 1: Add Team Members via README Documentation (EASIEST)
+
+For hackathon submission purposes, you MUST document your team in the Space's README.md file.
+
+### Steps:
+
+1. **Edit the Team Section in README.md**
+
+   The Team section is already added to your README. Update it with your actual team information:
+
+   ```markdown
+   ## 👥 Team
+
+   **Team Name:** FleetMind AI Team
+
+   **Team Members:**
+   - **John Doe** - [@johndoe](https://huggingface.co/johndoe) - Lead Developer & AI Architect
+   - **Jane Smith** - [@janesmith](https://huggingface.co/janesmith) - Database Engineer
+   - **Alex Chen** - [@alexchen](https://huggingface.co/alexchen) - UI/UX Developer
+   ```
+
+2. **Replace Placeholders:**
+   - `[Your Team Name]` → Your actual team name
+   - `[Your Name]` → Team member's real name
+   - `@your-hf-username` → Their Hugging Face username
+   - `[Role]` → Their role in the project
+
+3. **Commit and Push:**
+
+   ```bash
+   cd F:\fleetmind-mcp\fleetmind-dispatch-ai
+   git add README.md
+   git commit -m "Update team member information"
+   git push
+   ```
+
+---
+
+## Method 2: Grant Git Access to Team Partners (TECHNICAL COLLABORATION)
+
+If your team partners need to push code directly to the Space, they need Git access.
+
+### Option A: Via Organization Membership
+
+Since your Space is owned by the **MCP-1st-Birthday organization**, team members can:
+
+1. **Join the Organization:**
+   - Go to https://huggingface.co/MCP-1st-Birthday
+   - Click **"Request to join this org"** (top right)
+   - Fill out the registration form
+   - Wait for admin approval
+
+2. **Verify Access:**
+   - Once approved, they'll automatically have access based on organization permissions
+   - Organization members with "write" or "contributor" roles can collaborate
+
+### Option B: Direct Collaborator Access
+
+If you have admin rights to your Space:
+
+1. **Go to Space Settings:**
+   - Visit: https://huggingface.co/spaces/MCP-1st-Birthday/fleetmind-dispatch-ai/settings
+   - Look for "Collaborators" or "Access" section
+
+2. **Add Collaborators by Username:**
+   - Enter their Hugging Face username
+   - Set their permission level (read/write/admin)
+   - Send invitation
+
+---
+
+## Method 3: Collaborate via Pull Requests (SAFEST)
+
+Team members can contribute without direct write access using Pull Requests.
+
+### Steps:
+
+1. **Team Partner Forks/Duplicates the Space:**
+   - They go to your Space page
+   - Click the three dots (top right) → "Duplicate this Space"
+   - Make changes in their forked version
+
+2. **Create Pull Request:**
+   - After making changes, they create a Pull Request
+   - You review and merge their changes
+
+3. **Enable Pull Requests:**
+   - Go to Space Settings
+   - Ensure "Pull Requests" are enabled
+
+---
+
+## Method 4: Share Git Credentials (NOT RECOMMENDED)
+
+While technically possible, sharing your Git credentials is NOT recommended for security reasons. Use Methods 1-3 instead.
+
+---
+
+## Technical Setup for Team Partners
+
+Once your team partners have access, they need to set up their local environment:
+
+### 1. Clone the Space
+
+```bash
+# Navigate to desired directory
+cd F:\
+
+# Clone the Space
+git clone https://huggingface.co/spaces/MCP-1st-Birthday/fleetmind-dispatch-ai
+
+# Enter directory
+cd fleetmind-dispatch-ai
+```
+
+### 2. Authenticate with Hugging Face
+
+They need a Hugging Face access token:
+
+1. **Get Token:**
+   - Go to https://huggingface.co/settings/tokens
+   - Click "New token"
+   - Create a token with "write" permissions
+
+2. **Login via CLI:**
+   ```bash
+   # Install Hugging Face CLI
+   pip install huggingface_hub
+
+   # Login (they'll be prompted for token)
+   huggingface-cli login
+   ```
+
+3. **Or Configure Git Credentials:**
+   ```bash
+   git config credential.helper store
+   ```
+
+   When they push for the first time, Git will ask for:
+   - Username: Their HF username
+   - Password: Their HF access token (NOT their account password)
+
+### 3. Make Changes and Push
+
+```bash
+# Make changes to files
+# ...
+
+# Stage changes
+git add .
+
+# Commit
+git commit -m "Add feature X"
+
+# Push to Space
+git push
+```
+
+---
+
+## Hugging Face Spaces Access Levels
+
+Understanding permission levels helps you decide what access to grant:
+
+| Role | Can View | Can Clone | Can Push | Can Manage Settings |
+|------|----------|-----------|----------|---------------------|
+| **Public** | ✅ | ✅ | ❌ | ❌ |
+| **Read** | ✅ | ✅ | ❌ | ❌ |
+| **Contributor** | ✅ | ✅ | Via PR only | ❌ |
+| **Write** | ✅ | ✅ | ✅ | ❌ |
+| **Admin** | ✅ | ✅ | ✅ | ✅ |
+
+---
+
+## Hackathon Submission Requirements
+
+For your team submission to be valid, ensure:
+
+### Required in README.md:
+- ✅ **Team section** with all member names and HF usernames
+- ✅ **Track tag:** `mcp-in-action-track-01` (already added)
+- ✅ **Demo video link** (1-5 minutes) - TODO
+- ✅ **Social media post link** - TODO
+
+### Required in Space:
+- ✅ Published as a Space in MCP-1st-Birthday organization
+- ✅ App.py entry point (already created)
+- ✅ Working Gradio interface
+- ✅ All code created during hackathon period (Nov 14-30, 2025)
+
+---
+
+## Troubleshooting
+
+### "Permission denied" when team partner tries to push
+
+**Solution:**
+1. Verify they're added as collaborators with write access
+2. Check they're using the correct HF access token (not account password)
+3. Ensure token has "write" permissions
+
+### "Repository not found" error
+
+**Solution:**
+1. Verify the Space URL is correct
+2. Check they have at least "read" access
+3. Ensure they're logged in: `huggingface-cli whoami`
+
+### Team member can't see the Space
+
+**Solution:**
+1. If Space is private, add them as collaborators
+2. If Space is public (recommended for hackathon), they should see it
+3. Check organization membership status
+
+---
+
+## Best Practices for Team Collaboration
+
+1. **Communication:**
+   - Use Discord channel: agents-mcp-hackathon-winter25
+   - Create a team group chat
+   - Document decisions in README
+
+2. **Code Management:**
+   - Pull before making changes: `git pull`
+   - Commit frequently with clear messages
+   - Test locally before pushing
+
+3. **Task Distribution:**
+   - Assign specific files/features to team members
+   - Avoid editing the same files simultaneously
+   - Use TODO comments in code
+
+4. **Version Control:**
+   - Create branches for major features (optional)
+   - Use descriptive commit messages
+   - Review each other's code
+
+---
+
+## Quick Reference Commands
+
+```bash
+# Clone the Space
+git clone https://huggingface.co/spaces/MCP-1st-Birthday/fleetmind-dispatch-ai
+
+# Check current status
+git status
+
+# Pull latest changes
+git pull
+
+# Add all changes
+git add .
+
+# Commit with message
+git commit -m "Description of changes"
+
+# Push to Space
+git push
+
+# Check who you're logged in as
+huggingface-cli whoami
+
+# Login to HF
+huggingface-cli login
+```
+
+---
+
+## Support & Resources
+
+- **Hackathon Discord:** agents-mcp-hackathon-winter25 channel
+- **Office Hours:** November 17-28 with Gradio team
+- **HF Documentation:** https://huggingface.co/docs/hub/spaces
+- **Git Documentation:** https://git-scm.com/doc
+
+---
+
+## Timeline Reminder
+
+- **Start Date:** November 14, 2025
+- **Submission Deadline:** November 30, 2025 (11:59 PM UTC)
+- **Days Remaining:** Check dashboard regularly
+
+Make sure all team members are added to README.md before the deadline!
+
+---
+
+**Good luck with your hackathon submission! 🚀**

app.py

@@ -1,461 +1,27 @@
 """
-FleetMind MCP Server - Hugging Face Space Entry Point (Track 1)
-
-This file serves as the entry point for HuggingFace Space deployment.
-Exposes 29 MCP tools via Server-Sent Events (SSE) endpoint for AI clients.
-
-Architecture:
-    User → MCP Client (Claude Desktop, Continue, etc.)
-         → SSE Endpoint (this file)
-         → FleetMind MCP Server (server.py)
-         → Tools (chat/tools.py)
-         → Database (PostgreSQL)
-
-For Track 1: Building MCP Servers - Enterprise Category
-https://huggingface.co/MCP-1st-Birthday
-
-Compatible with:
-- Claude Desktop (via SSE transport)
-- Continue.dev (VS Code extension)
-- Cline (VS Code extension)
-- Any MCP client supporting SSE protocol
+FleetMind MCP - Hugging Face Spaces Entry Point
+This is the main entry point for the HF Space deployment
 """
 
-import os
 import sys
-import logging
 from pathlib import Path
 
-# Add project root to path
+# Add current directory to path
 sys.path.insert(0, str(Path(__file__).parent))
 
-# Configure logging for HuggingFace Space
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[logging.StreamHandler()]
-)
-logger = logging.getLogger(__name__)
-
-# Import the MCP server instance
-from server import mcp
-
-# ============================================================================
-# HUGGING FACE SPACE CONFIGURATION
-# ============================================================================
-
-# HuggingFace Space default port
-# NOTE: When using proxy.py, FastMCP runs on 7861 (internal port)
-# The proxy runs on 7860 (public) and forwards requests here
-HF_SPACE_PORT = int(os.getenv("PORT", 7861))
-HF_SPACE_HOST = os.getenv("HOST", "0.0.0.0")
-
-# ============================================================================
-# MAIN ENTRY POINT
-# ============================================================================
+# Import and launch the Gradio app
+from ui.app import create_interface
 
 if __name__ == "__main__":
-    logger.info("=" * 70)
-    logger.info("FleetMind MCP Server - HuggingFace Space (Track 1)")
-    logger.info("=" * 70)
-    logger.info("MCP Server: FleetMind Dispatch Coordinator v1.0.0")
-    logger.info("Protocol: Model Context Protocol (MCP)")
-    logger.info("Transport: Server-Sent Events (SSE)")
-    logger.info(f"SSE Endpoint: https://mcp-1st-birthday-fleetmind-dispatch-ai.hf.space/sse")
-    logger.info("=" * 70)
-    logger.info("Features:")
-    logger.info("  ✓ 29 AI Tools (Order + Driver + Assignment Management)")
-    logger.info("  ✓ 2 Real-Time Resources (orders://all, drivers://all)")
-    logger.info("  ✓ Gemini 2.0 Flash AI - Intelligent Assignment")
-    logger.info("  ✓ Google Maps API Integration (Routes + Geocoding)")
-    logger.info("  ✓ Weather-Aware Routing (OpenWeatherMap)")
-    logger.info("  ✓ PostgreSQL Database (Neon)")
-    logger.info("=" * 70)
-    logger.info("Compatible Clients:")
-    logger.info("  • Claude Desktop")
-    logger.info("  • Continue.dev (VS Code)")
-    logger.info("  • Cline (VS Code)")
-    logger.info("  • Any MCP-compatible client")
-    logger.info("=" * 70)
-    logger.info("How to Connect (Claude Desktop):")
-    logger.info('  Add to claude_desktop_config.json:')
-    logger.info('  {')
-    logger.info('    "mcpServers": {')
-    logger.info('      "fleetmind": {')
-    logger.info('        "command": "npx",')
-    logger.info('        "args": [')
-    logger.info('          "mcp-remote",')
-    logger.info('          "https://mcp-1st-birthday-fleetmind-dispatch-ai.hf.space/sse"')
-    logger.info('        ]')
-    logger.info('      }')
-    logger.info('    }')
-    logger.info('  }')
-    logger.info("=" * 70)
-    logger.info(f"Starting SSE server on {HF_SPACE_HOST}:{HF_SPACE_PORT}...")
-    logger.info("Waiting for MCP client connections...")
-    logger.info("=" * 70)
-
-    try:
-        # Add web routes for landing page and API key generation
-        from starlette.responses import HTMLResponse, JSONResponse
-        from starlette.requests import Request
-        from database.api_keys import generate_api_key as db_generate_api_key
-
-        # =====================================================================
-        # PROXY-BASED AUTHENTICATION
-        # Authentication is handled by proxy.py (port 7860)
-        # The proxy captures API keys from SSE connections and injects them
-        # into tool requests before forwarding to FastMCP (port 7861)
-        # =====================================================================
-        logger.info("[Auth] Using proxy-based authentication")
-        logger.info("[Auth] Proxy captures API keys and injects into tool requests")
-
-        @mcp.custom_route("/", methods=["GET"])
-        async def landing_page(request):
-            """Landing page with MCP connection information"""
-            return HTMLResponse("""
-<!DOCTYPE html>
-<html>
-<head>
-    <title>FleetMind MCP Server</title>
-    <style>
-        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Arial, sans-serif; max-width: 1000px; margin: 50px auto; padding: 20px; background: #0f172a; color: #e2e8f0; }
-        .container { background: #1e293b; padding: 40px; border-radius: 12px; box-shadow: 0 8px 16px rgba(0,0,0,0.4); }
-        h1 { color: #f1f5f9; margin-top: 0; }
-        h2 { color: #e2e8f0; border-bottom: 2px solid #334155; padding-bottom: 10px; }
-        h3 { color: #cbd5e1; }
-        code { background: #334155; color: #60a5fa; padding: 3px 8px; border-radius: 4px; font-family: 'Courier New', monospace; }
-        pre { background: #0f172a; color: #f1f5f9; padding: 20px; border-radius: 8px; overflow-x: auto; border: 1px solid #334155; }
-        .endpoint { background: #1e3a5f; padding: 15px; margin: 15px 0; border-left: 4px solid #3b82f6; border-radius: 4px; }
-        .feature { background: #134e4a; padding: 15px; margin: 10px 0; border-left: 4px solid #10b981; border-radius: 4px; }
-        .badge { display: inline-block; background: #3b82f6; color: white; padding: 4px 12px; border-radius: 12px; font-size: 12px; margin: 5px; }
-        a { color: #60a5fa; text-decoration: none; }
-        a:hover { text-decoration: underline; color: #93c5fd; }
-        ol { line-height: 1.8; }
-        ul { line-height: 1.8; }
-        p { color: #cbd5e1; }
-    </style>
-</head>
-<body>
-    <div class="container">
-        <h1>🚚 FleetMind MCP Server</h1>
-        <p><strong>Enterprise Model Context Protocol Server for AI-Powered Delivery Dispatch</strong></p>
-        <p><span class="badge">MCP 1st Birthday Hackathon</span> <span class="badge">Track 1: Building MCP</span> <span class="badge">Enterprise Category</span></p>
-
-        <hr style="margin: 30px 0; border: none; border-top: 1px solid #e5e7eb;">
-
-        <h2>🔌 MCP Server Connection</h2>
-
-        <div class="endpoint">
-            <strong>SSE Endpoint URL:</strong><br>
-            <code>https://mcp-1st-birthday-fleetmind-dispatch-ai.hf.space/sse</code>
-        </div>
-
-        <h3>🔑 Step 1: Get Your API Key</h3>
-        <p style="text-align: center; margin: 20px 0;">
-            <a href="/generate-key" style="display: inline-block; background: #3b82f6; color: white; padding: 15px 30px; border-radius: 8px; text-decoration: none; font-weight: bold; font-size: 18px;">
-                Generate API Key →
-            </a>
-        </p>
-        <p>Click the button above to generate your unique API key. You'll need this to authenticate with the server.</p>
-
-        <h3>⚙️ Step 2: Configure Claude Desktop</h3>
-        <p>Add this to your <code>claude_desktop_config.json</code> file:</p>
-        <pre>{
-  "mcpServers": {
-    "fleetmind": {
-      "command": "npx",
-      "args": [
-        "mcp-remote",
-        "https://mcp-1st-birthday-fleetmind-dispatch-ai.hf.space/sse<strong style="color: #60a5fa;">?api_key=fm_your_api_key_here</strong>"
-      ]
-    }
-  }
-}</pre>
-        <p style="background: #1e3a5f; padding: 10px; border-radius: 6px; margin: 10px 0; border-left: 4px solid #3b82f6;">
-            💡 <strong>Important:</strong> Add your API key as a query parameter (<code>?api_key=...</code>) in the URL, not in the <code>env</code> section!
-        </p>
-
-        <h3>📋 Step 3: Connect</h3>
-        <ol>
-            <li><strong>Generate your API key</strong> using the button above</li>
-            <li>Install <a href="https://claude.ai/download" target="_blank">Claude Desktop</a></li>
-            <li>Locate your <code>claude_desktop_config.json</code> file</li>
-            <li>Add the configuration, replacing <code>fm_your_api_key_here</code> with your actual API key <strong>in the URL</strong></li>
-            <li>Restart Claude Desktop</li>
-            <li>Look for "FleetMind" in the 🔌 tools menu</li>
-        </ol>
-
-        <hr style="margin: 30px 0; border: none; border-top: 1px solid #e5e7eb;">
-
-        <h2>🛠️ Available Tools (29 Total)</h2>
-
-        <div class="feature">
-            <strong>📍 Geocoding & Routing (3 tools):</strong><br>
-            geocode_address, calculate_route, calculate_intelligent_route
-        </div>
-
-        <div class="feature">
-            <strong>📦 Order Management (8 tools):</strong><br>
-            create_order, count_orders, fetch_orders, get_order_details, search_orders, get_incomplete_orders, update_order, delete_order
-        </div>
-
-        <div class="feature">
-            <strong>👥 Driver Management (8 tools):</strong><br>
-            create_driver, count_drivers, fetch_drivers, get_driver_details, search_drivers, get_available_drivers, update_driver, delete_driver
-        </div>
-
-        <div class="feature">
-            <strong>🔗 Assignment Management (8 tools):</strong><br>
-            create_assignment, <strong>auto_assign_order</strong>, <strong>intelligent_assign_order</strong>, get_assignment_details, update_assignment, unassign_order, complete_delivery, fail_delivery
-        </div>
-
-        <div class="feature">
-            <strong>🗑️ Bulk Operations (2 tools):</strong><br>
-            delete_all_orders, delete_all_drivers
-        </div>
-
-        <hr style="margin: 30px 0; border: none; border-top: 1px solid #e5e7eb;">
-
-        <h2>⭐ Key Features</h2>
-        <ul>
-            <li><strong>🔑 API Key Authentication</strong> - Secure multi-tenant access with personal API keys (URL-based)</li>
-            <li><strong>👥 Multi-Tenant Isolation</strong> - Complete data separation via user_id (deterministic from email)</li>
-            <li><strong>🧠 Gemini 2.0 Flash AI</strong> - Intelligent order assignment with detailed reasoning</li>
-            <li><strong>🌦️ Weather-Aware Routing</strong> - Safety-first delivery planning with OpenWeatherMap</li>
-            <li><strong>🚦 Real-Time Traffic</strong> - Google Routes API integration with live traffic data</li>
-            <li><strong>📊 SLA Tracking</strong> - Automatic on-time performance monitoring</li>
-            <li><strong>🗄️ PostgreSQL Database</strong> - Production-grade data storage with user_id filtering (Neon)</li>
-            <li><strong>🚀 Multi-Client Support</strong> - Works with Claude Desktop, Continue, Cline, any MCP client</li>
-        </ul>
-
-        <h2>🔒 Authentication & Security</h2>
-        <div class="feature">
-            <strong>How Authentication Works:</strong><br>
-            1. Generate API key via <a href="/generate-key">/generate-key</a><br>
-            2. API key hashed (SHA-256) before storage<br>
-            3. User ID generated: <code>user_&#123;MD5(email)[:12]&#125;</code><br>
-            4. Add key to URL: <code>?api_key=fm_...</code><br>
-            5. Server validates on each SSE connection<br>
-            6. All queries filter by user_id for isolation
-        </div>
-        <div class="feature">
-            <strong>Security Features:</strong><br>
-            ✅ One-Time Display (keys shown once)<br>
-            ✅ Hashed Storage (SHA-256, never plaintext)<br>
-            ✅ Database-Level Isolation (all tables have user_id)<br>
-            ✅ Deterministic User IDs (same email → same user_id)<br>
-            ✅ Production Safeguards (ENV-based SKIP_AUTH protection)
-        </div>
-
-        <hr style="margin: 30px 0; border: none; border-top: 1px solid #e5e7eb;">
-
-        <h2>📚 Resources</h2>
-        <ul>
-            <li><strong>GitHub:</strong> <a href="https://github.com/mashrur-rahman-fahim/fleetmind-mcp" target="_blank">mashrur-rahman-fahim/fleetmind-mcp</a></li>
-            <li><strong>HuggingFace Space:</strong> <a href="https://huggingface.co/spaces/MCP-1st-Birthday/fleetmind-dispatch-ai" target="_blank">MCP-1st-Birthday/fleetmind-dispatch-ai</a></li>
-            <li><strong>MCP Protocol Docs:</strong> <a href="https://modelcontextprotocol.io" target="_blank">modelcontextprotocol.io</a></li>
-        </ul>
-
-        <hr style="margin: 30px 0; border: none; border-top: 1px solid #e5e7eb;">
-
-        <p style="text-align: center; color: #6b7280; font-size: 14px;">
-            FleetMind v1.0 - Built for MCP 1st Birthday Hackathon<br>
-            29 AI Tools | 2 Real-Time Resources | Enterprise-Ready
-        </p>
-    </div>
-</body>
-</html>
-            """)
-
-        @mcp.custom_route("/generate-key", methods=["GET", "POST"])
-        async def generate_key_page(request):
-            """API Key generation page"""
-            if request.method == "GET":
-                return HTMLResponse("""
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Generate FleetMind API Key</title>
-    <style>
-        body { font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Arial, sans-serif; max-width: 600px; margin: 50px auto; padding: 20px; background: #0f172a; color: #e2e8f0; }
-        .container { background: #1e293b; padding: 40px; border-radius: 12px; box-shadow: 0 8px 16px rgba(0,0,0,0.4); }
-        h1 { color: #f1f5f9; }
-        input { width: 100%; padding: 12px; margin: 10px 0; border-radius: 6px; border: 1px solid #334155; background: #0f172a; color: #e2e8f0; font-size: 16px; }
-        button { background: #3b82f6; color: white; border: none; padding: 12px 24px; border-radius: 6px; font-size: 16px; cursor: pointer; width: 100%; }
-        button:hover { background: #2563eb; }
-        button:disabled { background: #64748b; cursor: not-allowed; opacity: 0.6; }
-        .info { background: #1e3a5f; padding: 15px; border-radius: 6px; margin: 15px 0; border-left: 4px solid #3b82f6; }
-    </style>
-    <script>
-        function handleGenerateKey(event) {
-            const button = event.target.querySelector('button');
-            button.textContent = 'Generating...';
-            button.disabled = true;
-        }
-    </script>
-</head>
-<body>
-    <div class="container">
-        <h1>🔑 Generate API Key</h1>
-        <p>Create your FleetMind MCP Server API key</p>
-
-        <div class="info">
-            <strong>📋 What you'll need:</strong><br>
-            • Your email address (used to generate your unique user_id)<br>
-            • Your name (optional)<br>
-            <br>
-            <strong>🔐 What you'll get:</strong><br>
-            • API Key: <code>fm_xxxxx...</code> (show once, copy immediately!)<br>
-            • User ID: <code>user_xxxxx</code> (deterministic from your email)<br>
-            • All your data (orders/drivers/assignments) will be isolated by this user_id
-        </div>
-
-        <form method="POST" onsubmit="handleGenerateKey(event)">
-            <input type="email" name="email" placeholder="Your email address" required>
-            <input type="text" name="name" placeholder="Your name (optional)">
-            <button type="submit">Generate API Key</button>
-        </form>
-
-        <p style="text-align: center; margin-top: 20px;">
-            <a href="/" style="color: #60a5fa; text-decoration: none;">← Back to Home</a>
-        </p>
-    </div>
-</body>
-</html>
-                """)
-
-            # POST - Generate API key
-            else:
-                try:
-                    form_data = await request.form()
-                    email = form_data.get("email")
-                    name = form_data.get("name") or None
-
-                    if not email:
-                        return HTMLResponse("<h1>Error: Email is required</h1>", status_code=400)
-
-                    result = db_generate_api_key(email, name)
-
-                    if not result['success']:
-                        return HTMLResponse(f"<h1>Error: {result['error']}</h1>", status_code=400)
-
-                    # Success - show the API key (one time only!)
-                    return HTMLResponse(f"""
-<!DOCTYPE html>
-<html>
-<head>
-    <title>Your FleetMind API Key</title>
-    <style>
-        body {{ font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Arial, sans-serif; max-width: 800px; margin: 50px auto; padding: 20px; background: #0f172a; color: #e2e8f0; }}
-        .container {{ background: #1e293b; padding: 40px; border-radius: 12px; box-shadow: 0 8px 16px rgba(0,0,0,0.4); }}
-        h1 {{ color: #f1f5f9; }}
-        .success {{ background: #10b981; padding: 15px; border-radius: 6px; margin: 15px 0; }}
-        .warning {{ background: #ef4444; padding: 15px; border-radius: 6px; margin: 15px 0; }}
-        code {{ background: #334155; color: #60a5fa; padding: 3px 8px; border-radius: 4px; font-family: 'Courier New', monospace; display: block; margin: 10px 0; word-wrap: break-word; font-size: 14px; }}
-        pre {{ background: #0f172a; color: #f1f5f9; padding: 20px; border-radius: 8px; overflow-x: auto; border: 1px solid #334155; }}
-        button {{ background: #3b82f6; color: white; border: none; padding: 12px 24px; border-radius: 6px; font-size: 16px; cursor: pointer; margin: 10px 5px; }}
-        button:hover {{ background: #2563eb; }}
-    </style>
-    <script>
-        function copyKey() {{
-            navigator.clipboard.writeText('{result["api_key"]}');
-            alert('API key copied to clipboard!');
-        }}
-    </script>
-</head>
-<body>
-    <div class="container">
-        <h1>✅ API Key Generated!</h1>
-
-        <div class="success">
-            <strong>Your API key has been created successfully</strong>
-        </div>
-
-        <p><strong>📧 Email:</strong> {result["email"]}</p>
-        <p><strong>👤 Name:</strong> {result["name"]}</p>
-        <p><strong>🆔 User ID:</strong> <code>{result["user_id"]}</code></p>
-
-        <div class="warning">
-            <strong>⚠️ SAVE THIS KEY NOW - IT WON'T BE SHOWN AGAIN!</strong>
-        </div>
-
-        <h2>🔑 Your API Key:</h2>
-        <code>{result["api_key"]}</code>
-        <button onclick="copyKey()">📋 Copy Key</button>
-
-        <h2>👥 Multi-Tenant Isolation</h2>
-        <p style="background: #1e3a5f; padding: 15px; border-radius: 6px; margin: 10px 0; border-left: 4px solid #3b82f6;">
-            <strong>Your user_id (<code>{result["user_id"]}</code>) ensures complete data isolation:</strong><br>
-            ✅ You will only see your own orders, drivers, and assignments<br>
-            ✅ All database operations automatically filter by your user_id<br>
-            ✅ Your user_id is deterministic - same email always gets same ID<br>
-            ✅ Even if you regenerate your API key, your user_id stays the same
-        </p>
-
-        <h2>📋 Claude Desktop Setup:</h2>
-        <p>Add this to your <code>claude_desktop_config.json</code>:</p>
-        <pre>{{
-  "mcpServers": {{
-    "fleetmind": {{
-      "command": "npx",
-      "args": [
-        "mcp-remote",
-        "https://mcp-1st-birthday-fleetmind-dispatch-ai.hf.space/sse?api_key={result["api_key"]}"
-      ]
-    }}
-  }}
-}}</pre>
-        <p style="background: #1e3a5f; padding: 10px; border-radius: 6px; margin: 10px 0; border-left: 4px solid #3b82f6;">
-            💡 <strong>Important:</strong> The API key is included in the URL as a query parameter (<code>?api_key=...</code>)
-        </p>
-
-        <h2>🚀 Next Steps:</h2>
-        <ol>
-            <li>Copy your API key (click the button above)</li>
-            <li>Add it to your Claude Desktop config</li>
-            <li>Restart Claude Desktop</li>
-            <li>Start using FleetMind tools!</li>
-        </ol>
-
-        <h2>🔐 How Authentication Works:</h2>
-        <div style="background: #134e4a; padding: 15px; border-radius: 6px; margin: 10px 0; border-left: 4px solid #10b981;">
-            <strong>Authentication Flow:</strong><br><br>
-            1️⃣ <strong>Connection:</strong> Claude Desktop connects to SSE endpoint with your API key in URL<br>
-            2️⃣ <strong>Validation:</strong> Server hashes your key (SHA-256) and looks it up in database<br>
-            3️⃣ <strong>User Extraction:</strong> Server retrieves your user_id: <code>{result["user_id"]}</code><br>
-            4️⃣ <strong>Data Isolation:</strong> All tool calls automatically filter by your user_id<br>
-            5️⃣ <strong>Security:</strong> You can only access data associated with your user_id<br>
-        </div>
-
-        <p style="text-align: center; margin-top: 30px;">
-            <a href="/" style="color: #60a5fa; text-decoration: none;">← Back to Home</a>
-        </p>
-    </div>
-</body>
-</html>
-                    """)
-
-                except Exception as e:
-                    return HTMLResponse(f"<h1>Error: {str(e)}</h1>", status_code=500)
-
-        logger.info("[OK] Landing page added at / route")
-        logger.info("[OK] API key generation page added at /generate-key")
-        logger.info("[OK] MCP SSE endpoint available at /sse")
-        logger.info("[OK] Authentication handled by proxy.py (port 7860)")
-
-        # Run MCP server with SSE transport
-        # No middleware needed - proxy.py handles API key capture and injection
-        mcp.run(
-            transport="sse",
-            host=HF_SPACE_HOST,
-            port=HF_SPACE_PORT
-        )
-
-    except Exception as e:
-        logger.error(f"Failed to start server: {e}")
-        logger.error("Check that:")
-        logger.error("  1. Database connection is configured (DB_HOST, DB_USER, etc.)")
-        logger.error("  2. Google Maps API key is set (GOOGLE_MAPS_API_KEY)")
-        logger.error("  3. Port 7860 is available")
-        raise
+    print("=" * 60)
+    print("FleetMind MCP - Starting on Hugging Face Spaces")
+    print("=" * 60)
+
+    # Create and launch the interface
+    app = create_interface()
+    app.launch(
+        server_name="0.0.0.0",
+        server_port=7860,
+        share=False,
+        show_error=True
+    )

chat/__init__.py

@@ -1,9 +1,9 @@
 """
-Chat package for FleetMind MCP Server (Track 1)
-Contains geocoding service and tool handlers for MCP server
+Chat package for FleetMind MCP
+Handles AI-powered natural language order creation
 """
 
-# Only tools and geocoding are needed for MCP server
-# ChatEngine and ConversationManager are archived (were for Gradio UI)
+from .chat_engine import ChatEngine
+from .conversation import ConversationManager
 
-__all__ = []
+__all__ = ['ChatEngine', 'ConversationManager']

chat/chat_engine.py

@@ -0,0 +1,108 @@
+"""
+Chat engine for FleetMind
+Main orchestrator for AI-powered conversations with multi-provider support
+"""
+
+import os
+import logging
+from typing import Tuple, List, Dict
+
+from chat.providers import ClaudeProvider, GeminiProvider
+
+logger = logging.getLogger(__name__)
+
+
+class ChatEngine:
+    """Main orchestrator for AI chat conversations with multi-provider support"""
+
+    def __init__(self):
+        # Get provider selection from environment
+        provider_name = os.getenv("AI_PROVIDER", "anthropic").lower()
+
+        logger.info(f"ChatEngine: Selected provider: {provider_name}")
+
+        # Initialize the selected provider
+        if provider_name == "gemini":
+            self.provider = GeminiProvider()
+            logger.info("ChatEngine: Using Gemini provider")
+        elif provider_name == "anthropic":
+            self.provider = ClaudeProvider()
+            logger.info("ChatEngine: Using Claude provider")
+        else:
+            # Default to Claude if unknown provider
+            logger.warning(f"ChatEngine: Unknown provider '{provider_name}', defaulting to Claude")
+            self.provider = ClaudeProvider()
+
+        # Store provider name for UI
+        self.selected_provider = provider_name
+
+    def is_available(self) -> bool:
+        """Check if the chat engine is available"""
+        return self.provider.is_available()
+
+    def get_status(self) -> str:
+        """Get status message for UI"""
+        provider_status = self.provider.get_status()
+        provider_name = self.provider.get_provider_name()
+
+        return f"**{provider_name}:** {provider_status}"
+
+    def get_provider_name(self) -> str:
+        """Get the active provider name"""
+        return self.provider.get_provider_name()
+
+    def get_model_name(self) -> str:
+        """Get the active model name"""
+        return self.provider.get_model_name()
+
+    def process_message(
+        self,
+        user_message: str,
+        conversation
+    ) -> Tuple[str, List[Dict]]:
+        """
+        Process user message and return AI response
+
+        Args:
+            user_message: User's message
+            conversation: ConversationManager instance
+
+        Returns:
+            Tuple of (assistant_response, tool_calls_made)
+        """
+        return self.provider.process_message(user_message, conversation)
+
+    def get_welcome_message(self) -> str:
+        """Get welcome message for new conversations"""
+        return self.provider.get_welcome_message()
+
+    def get_full_status(self) -> Dict[str, str]:
+        """
+        Get detailed status for all providers
+
+        Returns:
+            Dict with status for each provider
+        """
+        # Get status without creating new instances (avoid API calls)
+        claude_key = os.getenv("ANTHROPIC_API_KEY", "")
+        gemini_key = os.getenv("GOOGLE_API_KEY", "")
+
+        claude_available = bool(claude_key and not claude_key.startswith("your_"))
+        gemini_available = bool(gemini_key and not gemini_key.startswith("your_"))
+
+        claude_status = "✅ Connected - Model: claude-3-5-sonnet-20241022" if claude_available else "⚠️ Not configured (add ANTHROPIC_API_KEY)"
+        gemini_status = f"✅ Connected - Model: {self.provider.get_model_name()}" if (self.selected_provider == "gemini" and gemini_available) else "⚠️ Not configured (add GOOGLE_API_KEY)" if not gemini_available else "✅ Configured"
+
+        return {
+            "selected": self.selected_provider,
+            "claude": {
+                "name": "Claude (Anthropic)",
+                "status": claude_status,
+                "available": claude_available
+            },
+            "gemini": {
+                "name": "Gemini (Google)",
+                "status": gemini_status,
+                "available": gemini_available
+            }
+        }

chat/conversation.py

@@ -0,0 +1,85 @@
+"""
+Conversation manager for FleetMind chat
+Handles conversation state and history
+"""
+
+import logging
+from typing import List, Dict
+
+logger = logging.getLogger(__name__)
+
+
+class ConversationManager:
+    """Manage conversation state and history"""
+
+    def __init__(self):
+        self.history = []
+        self.tool_calls = []  # Track all tool calls for transparency
+        self.order_context = {}  # Accumulated order details
+
+    def add_message(self, role: str, content: str):
+        """
+        Add message to conversation history
+
+        Args:
+            role: "user" or "assistant"
+            content: Message content
+        """
+        self.history.append({
+            "role": role,
+            "content": content
+        })
+
+    def add_tool_result(self, tool_name: str, tool_input: dict, tool_result: dict):
+        """
+        Track tool usage for transparency
+
+        Args:
+            tool_name: Name of the tool called
+            tool_input: Input parameters
+            tool_result: Result from tool execution
+        """
+        self.tool_calls.append({
+            "tool": tool_name,
+            "input": tool_input,
+            "result": tool_result
+        })
+
+    def get_history(self) -> List[Dict]:
+        """Get full conversation history"""
+        return self.history
+
+    def get_tool_calls(self) -> List[Dict]:
+        """Get all tool calls made in this conversation"""
+        return self.tool_calls
+
+    def get_last_tool_call(self) -> Dict:
+        """Get the most recent tool call"""
+        if self.tool_calls:
+            return self.tool_calls[-1]
+        return {}
+
+    def clear_tool_calls(self):
+        """Clear tool call history"""
+        self.tool_calls = []
+
+    def reset(self):
+        """Start a new conversation"""
+        self.history = []
+        self.tool_calls = []
+        self.order_context = {}
+        logger.info("Conversation reset")
+
+    def get_message_count(self) -> int:
+        """Get number of messages in conversation"""
+        return len(self.history)
+
+    def get_formatted_history(self) -> List[Dict]:
+        """
+        Get history formatted for Gradio chatbot (messages format)
+
+        Returns:
+            List of message dictionaries with 'role' and 'content' keys
+        """
+        # For Gradio type="messages", return list of dicts with role/content
+        return self.history

chat/geocoding.py

@@ -1,23 +1,15 @@
 """
 Geocoding service for FleetMind
-Handles address validation with Google Maps API and smart mock fallback
+Handles address validation with HERE API and smart mock fallback
 """
 
 import os
-import googlemaps
+import requests
 import logging
-import asyncio
-from concurrent.futures import ThreadPoolExecutor
 from typing import Dict, Optional
 
 logger = logging.getLogger(__name__)
 
-# Thread pool for running blocking geocoding calls
-_geocoding_executor = ThreadPoolExecutor(max_workers=3, thread_name_prefix="geocoding")
-
-# Timeout for geocoding operations (seconds)
-GEOCODING_TIMEOUT = 10
-
 # Common city coordinates for mock geocoding
 CITY_COORDINATES = {
     "san francisco": (37.7749, -122.4194),
@@ -44,33 +36,20 @@ CITY_COORDINATES = {
 
 
 class GeocodingService:
-    """Handle address geocoding with Google Maps API and smart mock fallback"""
+    """Handle address geocoding with HERE API and smart mock fallback"""
 
     def __init__(self):
-        self.google_maps_key = os.getenv("GOOGLE_MAPS_API_KEY", "")
-        self.use_mock = not self.google_maps_key or self.google_maps_key.startswith("your_")
+        self.here_api_key = os.getenv("HERE_API_KEY", "")
+        self.use_mock = not self.here_api_key or self.here_api_key.startswith("your_")
 
         if self.use_mock:
-            logger.info("Geocoding: Using mock (GOOGLE_MAPS_API_KEY not configured)")
-            self.gmaps_client = None
+            logger.info("Geocoding: Using mock (HERE_API_KEY not configured)")
         else:
-            try:
-                # Configure with timeout to prevent hanging
-                self.gmaps_client = googlemaps.Client(
-                    key=self.google_maps_key,
-                    timeout=GEOCODING_TIMEOUT,  # 10 second timeout
-                    retry_timeout=GEOCODING_TIMEOUT  # Total retry timeout
-                )
-                logger.info("Geocoding: Using Google Maps API (timeout: 10s)")
-            except Exception as e:
-                logger.error(f"Failed to initialize Google Maps client: {e}")
-                self.use_mock = True
-                self.gmaps_client = None
+            logger.info("Geocoding: Using HERE Maps API")
 
     def geocode(self, address: str) -> Dict:
         """
-        Geocode address, using mock if API unavailable.
-        This is a synchronous method with built-in timeout.
+        Geocode address, using mock if API unavailable
 
         Args:
             address: Street address to geocode
@@ -82,65 +61,40 @@ class GeocodingService:
             return self._geocode_mock(address)
         else:
             try:
-                return self._geocode_google(address)
+                return self._geocode_here(address)
             except Exception as e:
-                logger.error(f"Google Maps API failed: {e}, falling back to mock")
+                logger.error(f"HERE API failed: {e}, falling back to mock")
                 return self._geocode_mock(address)
 
-    async def geocode_async(self, address: str) -> Dict:
-        """
-        Async-safe geocoding that runs blocking calls in a thread pool.
-        Use this in async contexts to prevent blocking the event loop.
-
-        Args:
-            address: Street address to geocode
-
-        Returns:
-            Dict with keys: lat, lng, formatted_address, confidence
-        """
-        if self.use_mock:
-            return self._geocode_mock(address)
+    def _geocode_here(self, address: str) -> Dict:
+        """Real HERE API geocoding"""
+        url = "https://geocode.search.hereapi.com/v1/geocode"
 
-        loop = asyncio.get_event_loop()
-        try:
-            # Run blocking geocode in thread pool with timeout
-            result = await asyncio.wait_for(
-                loop.run_in_executor(_geocoding_executor, self._geocode_google, address),
-                timeout=GEOCODING_TIMEOUT + 2  # Extra buffer beyond client timeout
-            )
-            return result
-        except asyncio.TimeoutError:
-            logger.error(f"Geocoding timed out for address: {address}, falling back to mock")
-            return self._geocode_mock(address)
-        except Exception as e:
-            logger.error(f"Async geocoding failed: {e}, falling back to mock")
-            return self._geocode_mock(address)
+        params = {
+            "q": address,
+            "apiKey": self.here_api_key
+        }
 
-    def _geocode_google(self, address: str) -> Dict:
-        """Real Google Maps API geocoding"""
-        try:
-            # Call Google Maps Geocoding API
-            result = self.gmaps_client.geocode(address)
+        response = requests.get(url, params=params, timeout=10)
+        response.raise_for_status()
 
-            if not result:
-                # No results found, fall back to mock
-                logger.warning(f"Google Maps API found no results for: {address}")
-                return self._geocode_mock(address)
+        data = response.json()
 
-            # Get first result
-            first_result = result[0]
-            location = first_result['geometry']['location']
+        if not data.get("items"):
+            # No results found, fall back to mock
+            logger.warning(f"HERE API found no results for: {address}")
+            return self._geocode_mock(address)
 
-            return {
-                "lat": location['lat'],
-                "lng": location['lng'],
-                "formatted_address": first_result.get('formatted_address', address),
-                "confidence": "high (Google Maps API)"
-            }
+        # Get first result
+        item = data["items"][0]
+        position = item["position"]
 
-        except Exception as e:
-            logger.error(f"Google Maps geocoding error: {e}")
-            raise
+        return {
+            "lat": position["lat"],
+            "lng": position["lng"],
+            "formatted_address": item.get("address", {}).get("label", address),
+            "confidence": "high (HERE API)"
+        }
 
     def _geocode_mock(self, address: str) -> Dict:
         """
@@ -169,144 +123,9 @@ class GeocodingService:
             "confidence": "low (mock - default)"
         }
 
-    def reverse_geocode(self, lat: float, lng: float) -> Dict:
-        """
-        Reverse geocode coordinates to address.
-        This is a synchronous method with built-in timeout.
-
-        Args:
-            lat: Latitude
-            lng: Longitude
-
-        Returns:
-            Dict with keys: address, city, state, country, formatted_address
-        """
-        if self.use_mock:
-            return self._reverse_geocode_mock(lat, lng)
-        else:
-            try:
-                return self._reverse_geocode_google(lat, lng)
-            except Exception as e:
-                logger.error(f"Google Maps reverse geocoding failed: {e}, falling back to mock")
-                return self._reverse_geocode_mock(lat, lng)
-
-    async def reverse_geocode_async(self, lat: float, lng: float) -> Dict:
-        """
-        Async-safe reverse geocoding that runs blocking calls in a thread pool.
-        Use this in async contexts to prevent blocking the event loop.
-
-        Args:
-            lat: Latitude
-            lng: Longitude
-
-        Returns:
-            Dict with keys: address, city, state, country, formatted_address
-        """
-        if self.use_mock:
-            return self._reverse_geocode_mock(lat, lng)
-
-        loop = asyncio.get_event_loop()
-        try:
-            # Run blocking reverse_geocode in thread pool with timeout
-            result = await asyncio.wait_for(
-                loop.run_in_executor(
-                    _geocoding_executor,
-                    self._reverse_geocode_google,
-                    lat,
-                    lng
-                ),
-                timeout=GEOCODING_TIMEOUT + 2
-            )
-            return result
-        except asyncio.TimeoutError:
-            logger.error(f"Reverse geocoding timed out for ({lat}, {lng}), falling back to mock")
-            return self._reverse_geocode_mock(lat, lng)
-        except Exception as e:
-            logger.error(f"Async reverse geocoding failed: {e}, falling back to mock")
-            return self._reverse_geocode_mock(lat, lng)
-
-    def _reverse_geocode_google(self, lat: float, lng: float) -> Dict:
-        """Real Google Maps API reverse geocoding"""
-        try:
-            # Call Google Maps Reverse Geocoding API
-            result = self.gmaps_client.reverse_geocode((lat, lng))
-
-            if not result:
-                logger.warning(f"Google Maps API found no results for: ({lat}, {lng})")
-                return self._reverse_geocode_mock(lat, lng)
-
-            # Get first result
-            first_result = result[0]
-
-            # Extract address components
-            address_components = first_result.get('address_components', [])
-            city = ""
-            state = ""
-            country = ""
-
-            for component in address_components:
-                types = component.get('types', [])
-                if 'locality' in types:
-                    city = component.get('long_name', '')
-                elif 'administrative_area_level_1' in types:
-                    state = component.get('short_name', '')
-                elif 'country' in types:
-                    country = component.get('long_name', '')
-
-            return {
-                "address": first_result.get('formatted_address', f"{lat}, {lng}"),
-                "city": city,
-                "state": state,
-                "country": country,
-                "formatted_address": first_result.get('formatted_address', f"{lat}, {lng}"),
-                "confidence": "high (Google Maps API)"
-            }
-
-        except Exception as e:
-            logger.error(f"Google Maps reverse geocoding error: {e}")
-            raise
-
-    def _reverse_geocode_mock(self, lat: float, lng: float) -> Dict:
-        """
-        Mock reverse geocoding
-        Tries to match coordinates to known cities
-        """
-        # Find closest city
-        min_distance = float('inf')
-        closest_city = "Unknown Location"
-
-        for city, coords in CITY_COORDINATES.items():
-            # Simple distance calculation
-            distance = ((lat - coords[0]) ** 2 + (lng - coords[1]) ** 2) ** 0.5
-            if distance < min_distance:
-                min_distance = distance
-                closest_city = city
-
-        # If very close to a known city (within ~0.1 degrees, roughly 11km)
-        if min_distance < 0.1:
-            logger.info(f"Mock reverse geocoding: Matched to {closest_city}")
-            return {
-                "address": f"Near {closest_city.title()}",
-                "city": closest_city.title(),
-                "state": "CA" if "san francisco" in closest_city or "la" in closest_city else "",
-                "country": "USA",
-                "formatted_address": f"Near {closest_city.title()}, USA",
-                "confidence": f"medium (mock - near {closest_city})"
-            }
-        else:
-            logger.info(f"Mock reverse geocoding: Unknown location at ({lat}, {lng})")
-            return {
-                "address": f"{lat}, {lng}",
-                "city": "",
-                "state": "",
-                "country": "",
-                "formatted_address": f"Coordinates: {lat}, {lng}",
-                "confidence": "low (mock - no match)"
-            }
-
     def get_status(self) -> str:
         """Get geocoding service status"""
         if self.use_mock:
-            return "⚠️ Using mock geocoding (add GOOGLE_MAPS_API_KEY for real)"
+            return "⚠️ Using mock geocoding (add HERE_API_KEY for real)"
         else:
-            return "✅ Google Maps API connected"
+            return "✅ HERE Maps API connected"

chat/providers/__init__.py

@@ -0,0 +1,10 @@
+"""
+AI Provider implementations for FleetMind chat
+Supports multiple AI providers (Anthropic Claude, Google Gemini)
+"""
+
+from .base_provider import AIProvider
+from .claude_provider import ClaudeProvider
+from .gemini_provider import GeminiProvider
+
+__all__ = ['AIProvider', 'ClaudeProvider', 'GeminiProvider']

chat/providers/base_provider.py

@@ -0,0 +1,53 @@
+"""
+Base provider interface for AI providers
+"""
+
+from abc import ABC, abstractmethod
+from typing import Tuple, List, Dict
+
+
+class AIProvider(ABC):
+    """Abstract base class for AI providers"""
+
+    @abstractmethod
+    def is_available(self) -> bool:
+        """Check if the provider is available (API key configured)"""
+        pass
+
+    @abstractmethod
+    def get_status(self) -> str:
+        """Get status message for UI"""
+        pass
+
+    @abstractmethod
+    def get_provider_name(self) -> str:
+        """Get provider name (e.g., 'Claude', 'Gemini')"""
+        pass
+
+    @abstractmethod
+    def get_model_name(self) -> str:
+        """Get model name (e.g., 'claude-3-5-sonnet-20241022')"""
+        pass
+
+    @abstractmethod
+    def process_message(
+        self,
+        user_message: str,
+        conversation
+    ) -> Tuple[str, List[Dict]]:
+        """
+        Process user message and return AI response
+
+        Args:
+            user_message: User's message
+            conversation: ConversationManager instance
+
+        Returns:
+            Tuple of (assistant_response, tool_calls_made)
+        """
+        pass
+
+    @abstractmethod
+    def get_welcome_message(self) -> str:
+        """Get welcome message for new conversations"""
+        pass

chat/providers/claude_provider.py

@@ -0,0 +1,271 @@
+"""
+Anthropic Claude provider for FleetMind chat
+"""
+
+import os
+import logging
+from typing import Tuple, List, Dict
+from anthropic import Anthropic, APIError, APIConnectionError, AuthenticationError
+
+from chat.providers.base_provider import AIProvider
+from chat.tools import TOOLS_SCHEMA, execute_tool
+
+logger = logging.getLogger(__name__)
+
+
+class ClaudeProvider(AIProvider):
+    """Anthropic Claude AI provider"""
+
+    def __init__(self):
+        self.api_key = os.getenv("ANTHROPIC_API_KEY", "")
+        self.api_available = bool(self.api_key and not self.api_key.startswith("your_"))
+
+        if self.api_available:
+            try:
+                self.client = Anthropic(api_key=self.api_key)
+                logger.info("ClaudeProvider: Initialized successfully")
+            except Exception as e:
+                logger.error(f"ClaudeProvider: Failed to initialize: {e}")
+                self.api_available = False
+        else:
+            self.client = None
+            logger.warning("ClaudeProvider: ANTHROPIC_API_KEY not configured")
+
+        self.model = "claude-3-5-sonnet-20241022"
+        self.system_prompt = self._get_system_prompt()
+
+    def _get_system_prompt(self) -> str:
+        """Get the system prompt for Claude"""
+        return """You are an AI assistant for FleetMind, a delivery dispatch system. Your job is to help coordinators create delivery orders efficiently.
+
+**IMPORTANT: When a user wants to create an order, FIRST show them this order form:**
+
+📋 **Order Information Form**
+Please provide the following details:
+
+**Required Fields:**
+• Customer Name: [Full name]
+• Delivery Address: [Street address, city, state, zip]
+• Contact: [Phone number OR email address]
+
+**Optional Fields:**
+• Delivery Deadline: [Date/time, or "ASAP" - default: 6 hours from now]
+• Priority: [standard/express/urgent - default: standard]
+• Special Instructions: [Any special notes]
+• Package Weight: [In kg - default: 5.0 kg]
+
+**Example:**
+"Customer: John Doe, Address: 123 Main St, San Francisco, CA 94103, Phone: 555-1234, Deliver by 5 PM today"
+
+---
+
+**Your Workflow:**
+1. **If user says "create order" or similar:** Show the form above and ask them to provide the information
+2. **If they provide all/most info:** Proceed immediately with geocoding and order creation
+3. **If information is missing:** Show what's missing from the form and ask for those specific fields
+4. **After collecting required fields:**
+   - Use `geocode_address` tool to validate the address
+   - Use `create_order` tool to save the order
+   - Provide a clear confirmation with order ID
+
+**Important Rules:**
+- ALWAYS geocode the address BEFORE creating an order
+- Be efficient - don't ask questions one at a time
+- Accept information in any format (natural language, bullet points, etc.)
+- Keep responses concise and professional
+- Show enthusiasm when orders are successfully created
+
+Remember: Dispatch coordinators are busy - help them create orders FAST!"""
+
+    def is_available(self) -> bool:
+        return self.api_available
+
+    def get_status(self) -> str:
+        if self.api_available:
+            return f"✅ Connected - Model: {self.model}"
+        return "⚠️ Not configured (add ANTHROPIC_API_KEY)"
+
+    def get_provider_name(self) -> str:
+        return "Claude (Anthropic)"
+
+    def get_model_name(self) -> str:
+        return self.model
+
+    def process_message(
+        self,
+        user_message: str,
+        conversation
+    ) -> Tuple[str, List[Dict]]:
+        """Process user message with Claude"""
+        if not self.api_available:
+            return self._handle_no_api(), []
+
+        # Add user message to history
+        conversation.add_message("user", user_message)
+
+        try:
+            # Make API call to Claude
+            response = self.client.messages.create(
+                model=self.model,
+                max_tokens=4096,
+                system=self.system_prompt,
+                tools=TOOLS_SCHEMA,
+                messages=conversation.get_history()
+            )
+
+            # Process response and handle tool calls
+            return self._process_response(response, conversation)
+
+        except AuthenticationError:
+            error_msg = "⚠️ Invalid API key. Please check your ANTHROPIC_API_KEY in .env file."
+            logger.error("Authentication error with Anthropic API")
+            return error_msg, []
+
+        except APIConnectionError:
+            error_msg = "⚠️ Cannot connect to Anthropic API. Please check your internet connection."
+            logger.error("Connection error with Anthropic API")
+            return error_msg, []
+
+        except APIError as e:
+            error_msg = f"⚠️ API error: {str(e)}"
+            logger.error(f"Anthropic API error: {e}")
+            return error_msg, []
+
+        except Exception as e:
+            error_msg = f"⚠️ Unexpected error: {str(e)}"
+            logger.error(f"Claude provider error: {e}")
+            return error_msg, []
+
+    def _process_response(
+        self,
+        response,
+        conversation
+    ) -> Tuple[str, List[Dict]]:
+        """Process Claude's response and handle tool calls"""
+        tool_calls_made = []
+
+        # Check if Claude wants to use tools
+        if response.stop_reason == "tool_use":
+            # Execute tools
+            tool_results = []
+
+            for content_block in response.content:
+                if content_block.type == "tool_use":
+                    tool_name = content_block.name
+                    tool_input = content_block.input
+
+                    logger.info(f"Claude executing tool: {tool_name}")
+
+                    # Execute the tool
+                    tool_result = execute_tool(tool_name, tool_input)
+
+                    # Track for transparency
+                    tool_calls_made.append({
+                        "tool": tool_name,
+                        "input": tool_input,
+                        "result": tool_result
+                    })
+
+                    conversation.add_tool_result(tool_name, tool_input, tool_result)
+
+                    # Prepare result for Claude
+                    tool_results.append({
+                        "type": "tool_result",
+                        "tool_use_id": content_block.id,
+                        "content": str(tool_result)
+                    })
+
+            # Add assistant's tool use to history
+            conversation.add_message("assistant", response.content)
+
+            # Add tool results to history
+            conversation.add_message("user", tool_results)
+
+            # Continue conversation with tool results
+            followup_response = self.client.messages.create(
+                model=self.model,
+                max_tokens=4096,
+                system=self.system_prompt,
+                tools=TOOLS_SCHEMA,
+                messages=conversation.get_history()
+            )
+
+            # Extract final text response
+            final_text = self._extract_text_response(followup_response)
+            conversation.add_message("assistant", final_text)
+
+            return final_text, tool_calls_made
+
+        else:
+            # No tool use, just text response
+            text_response = self._extract_text_response(response)
+            conversation.add_message("assistant", text_response)
+            return text_response, tool_calls_made
+
+    def _extract_text_response(self, response) -> str:
+        """Extract text content from Claude's response"""
+        text_parts = []
+        for block in response.content:
+            if hasattr(block, 'text'):
+                text_parts.append(block.text)
+            elif block.type == "text":
+                text_parts.append(block.text if hasattr(block, 'text') else str(block))
+
+        return "\n".join(text_parts) if text_parts else "I apologize, but I couldn't generate a response."
+
+    def _handle_no_api(self) -> str:
+        """Return error message when API is not available"""
+        return """⚠️ **Claude API requires Anthropic API key**
+
+To use Claude:
+
+1. Get an API key from: https://console.anthropic.com/
+   - Sign up for free ($5 credit available)
+   - Or use hackathon credits
+
+2. Add to your `.env` file:
+   ```
+   ANTHROPIC_API_KEY=sk-ant-your-key-here
+   ```
+
+3. Restart the application
+
+**Alternative:** Switch to Gemini by setting `AI_PROVIDER=gemini` in .env
+"""
+
+    def get_welcome_message(self) -> str:
+        if not self.api_available:
+            return self._handle_no_api()
+
+        return """👋 Hello! I'm your AI dispatch assistant powered by **Claude Sonnet 3.5**.
+
+I can help you create delivery orders quickly and efficiently!
+
+---
+
+📋 **To Create an Order, Provide:**
+
+**Required:**
+• Customer Name
+• Delivery Address
+• Contact (Phone OR Email)
+
+**Optional:**
+• Delivery Deadline (default: 6 hours)
+• Priority: standard/express/urgent (default: standard)
+• Special Instructions
+• Package Weight in kg (default: 5.0)
+
+---
+
+**Quick Start Examples:**
+
+✅ *Complete:* "Create order for John Doe, 123 Main St San Francisco CA, phone 555-1234, deliver by 5 PM"
+
+✅ *Partial:* "I need a delivery for Sarah" *(I'll ask for missing details)*
+
+✅ *Natural:* "Urgent package to john@email.com at 456 Market Street"
+
+---
+
+What would you like to do?"""

chat/providers/gemini_provider.py

@@ -0,0 +1,551 @@
+"""
+Google Gemini provider for FleetMind chat
+"""
+
+import os
+import logging
+from typing import Tuple, List, Dict
+import google.generativeai as genai
+from google.generativeai.types import HarmCategory, HarmBlockThreshold
+
+from chat.providers.base_provider import AIProvider
+from chat.tools import execute_tool
+
+logger = logging.getLogger(__name__)
+
+
+class GeminiProvider(AIProvider):
+    """Google Gemini AI provider"""
+
+    def __init__(self):
+        self.api_key = os.getenv("GOOGLE_API_KEY", "")
+        self.api_available = bool(self.api_key and not self.api_key.startswith("your_"))
+        self.model_name = "gemini-2.0-flash"
+        self.model = None
+        self._initialized = False
+
+        if not self.api_available:
+            logger.warning("GeminiProvider: GOOGLE_API_KEY not configured")
+        else:
+            logger.info("GeminiProvider: Ready (will initialize on first use)")
+
+    def _get_system_prompt(self) -> str:
+        """Get the system prompt for Gemini"""
+        return """You are an AI assistant for FleetMind, a delivery dispatch system.
+
+**🚨 CRITICAL RULES - READ CAREFULLY:**
+
+1. **NEVER return text in the middle of tool calls**
+   - If you need to call multiple tools, call them ALL in sequence
+   - Only return text AFTER all tools are complete
+
+2. **Order Creation MUST be a single automated flow:**
+   - Step 1: Call geocode_address (get coordinates)
+   - Step 2: IMMEDIATELY call create_order (save to database)
+   - Step 3: ONLY THEN return success message
+   - DO NOT stop between Step 1 and Step 2
+   - DO NOT say "Now creating order..." - just DO it!
+
+3. **Driver Creation is a SINGLE tool call:**
+   - When user wants to create a driver, call create_driver immediately
+   - NO geocoding needed for drivers
+   - Just call create_driver → confirm
+
+4. **If user provides required info, START IMMEDIATELY:**
+   - For Orders: Customer name, address, contact (phone OR email)
+   - For Drivers: Driver name (phone/email optional)
+   - If all present → execute → confirm
+   - If missing → ask ONCE for all missing fields
+
+**Example of CORRECT behavior:**
+
+ORDER:
+User: "Create order for John Doe, 123 Main St SF, phone 555-1234"
+You: [geocode_address] → [create_order] → "✅ Order ORD-123 created!"
+(ALL in one response, no intermediate text)
+
+DRIVER:
+User: "Add new driver Mike Johnson, phone 555-0101, drives a van"
+You: [create_driver] → "✅ Driver DRV-123 (Mike Johnson) added to fleet!"
+(Single tool call, immediate response)
+
+**Example of WRONG behavior (DO NOT DO THIS):**
+User: "Create order for John Doe..."
+You: [geocode_address] → "OK geocoded, now creating..." ❌ WRONG!
+
+**Available Tools:**
+- geocode_address: Convert address to GPS coordinates
+- create_order: Create customer delivery order (REQUIRES geocoded address)
+- create_driver: Add new driver/delivery man to fleet
+
+**Order Fields:**
+Required: customer_name, delivery_address, contact
+Optional: time_window_end, priority (standard/express/urgent), special_instructions, weight_kg
+
+**Driver Fields:**
+Required: name
+Optional: phone, email, vehicle_type (van/truck/car/motorcycle), vehicle_plate, capacity_kg, capacity_m3, skills (list), status (active/busy/offline)
+
+**Your goal:** Execute tasks in ONE smooth automated flow. No stopping, no intermediate messages!"""
+
+    def _get_gemini_tools(self) -> list:
+        """Convert tool schemas to Gemini function calling format"""
+        # Gemini expects tools wrapped in function_declarations
+        return [
+            genai.protos.Tool(
+                function_declarations=[
+                    genai.protos.FunctionDeclaration(
+                        name="geocode_address",
+                        description="Convert a delivery address to GPS coordinates and validate the address format. Use this before creating an order to ensure the address is valid.",
+                        parameters=genai.protos.Schema(
+                            type=genai.protos.Type.OBJECT,
+                            properties={
+                                "address": genai.protos.Schema(
+                                    type=genai.protos.Type.STRING,
+                                    description="The full delivery address to geocode (e.g., '123 Main St, San Francisco, CA')"
+                                )
+                            },
+                            required=["address"]
+                        )
+                    ),
+                    genai.protos.FunctionDeclaration(
+                        name="create_order",
+                        description="Create a new delivery order in the database. Only call this after geocoding the address successfully.",
+                        parameters=genai.protos.Schema(
+                            type=genai.protos.Type.OBJECT,
+                            properties={
+                                "customer_name": genai.protos.Schema(
+                                    type=genai.protos.Type.STRING,
+                                    description="Full name of the customer"
+                                ),
+                                "customer_phone": genai.protos.Schema(
+                                    type=genai.protos.Type.STRING,
+                                    description="Customer phone number (optional)"
+                                ),
+                                "customer_email": genai.protos.Schema(
+                                    type=genai.protos.Type.STRING,
+                                    description="Customer email address (optional)"
+                                ),
+                                "delivery_address": genai.protos.Schema(
+                                    type=genai.protos.Type.STRING,
+                                    description="Full delivery address"
+                                ),
+                                "delivery_lat": genai.protos.Schema(
+                                    type=genai.protos.Type.NUMBER,
+                                    description="Latitude from geocoding"
+                                ),
+                                "delivery_lng": genai.protos.Schema(
+                                    type=genai.protos.Type.NUMBER,
+                                    description="Longitude from geocoding"
+                                ),
+                                "time_window_end": genai.protos.Schema(
+                                    type=genai.protos.Type.STRING,
+                                    description="Delivery deadline in ISO format (e.g., '2025-11-13T17:00:00'). If not specified by user, default to 6 hours from now."
+                                ),
+                                "priority": genai.protos.Schema(
+                                    type=genai.protos.Type.STRING,
+                                    description="Delivery priority. Default to 'standard' unless user specifies urgent/express."
+                                ),
+                                "special_instructions": genai.protos.Schema(
+                                    type=genai.protos.Type.STRING,
+                                    description="Any special delivery instructions (optional)"
+                                ),
+                                "weight_kg": genai.protos.Schema(
+                                    type=genai.protos.Type.NUMBER,
+                                    description="Package weight in kilograms (optional, default to 5.0)"
+                                )
+                            },
+                            required=["customer_name", "delivery_address", "delivery_lat", "delivery_lng"]
+                        )
+                    ),
+                    genai.protos.FunctionDeclaration(
+                        name="create_driver",
+                        description="Create a new delivery driver/delivery man in the database. Use this to onboard new drivers to the fleet.",
+                        parameters=genai.protos.Schema(
+                            type=genai.protos.Type.OBJECT,
+                            properties={
+                                "name": genai.protos.Schema(
+                                    type=genai.protos.Type.STRING,
+                                    description="Full name of the driver"
+                                ),
+                                "phone": genai.protos.Schema(
+                                    type=genai.protos.Type.STRING,
+                                    description="Driver phone number"
+                                ),
+                                "email": genai.protos.Schema(
+                                    type=genai.protos.Type.STRING,
+                                    description="Driver email address (optional)"
+                                ),
+                                "vehicle_type": genai.protos.Schema(
+                                    type=genai.protos.Type.STRING,
+                                    description="Type of vehicle: van, truck, car, motorcycle (default: van)"
+                                ),
+                                "vehicle_plate": genai.protos.Schema(
+                                    type=genai.protos.Type.STRING,
+                                    description="Vehicle license plate number"
+                                ),
+                                "capacity_kg": genai.protos.Schema(
+                                    type=genai.protos.Type.NUMBER,
+                                    description="Vehicle cargo capacity in kilograms (default: 1000.0)"
+                                ),
+                                "capacity_m3": genai.protos.Schema(
+                                    type=genai.protos.Type.NUMBER,
+                                    description="Vehicle cargo volume in cubic meters (default: 12.0)"
+                                ),
+                                "skills": genai.protos.Schema(
+                                    type=genai.protos.Type.ARRAY,
+                                    description="List of driver skills/certifications: refrigerated, medical_certified, fragile_handler, overnight, express_delivery",
+                                    items=genai.protos.Schema(type=genai.protos.Type.STRING)
+                                ),
+                                "status": genai.protos.Schema(
+                                    type=genai.protos.Type.STRING,
+                                    description="Driver status: active, busy, offline, unavailable (default: active)"
+                                )
+                            },
+                            required=["name"]
+                        )
+                    )
+                ]
+            )
+        ]
+
+    def _ensure_initialized(self):
+        """Lazy initialization - only create model when first needed"""
+        if self._initialized or not self.api_available:
+            return
+
+        try:
+            genai.configure(api_key=self.api_key)
+            self.model = genai.GenerativeModel(
+                model_name=self.model_name,
+                tools=self._get_gemini_tools(),
+                system_instruction=self._get_system_prompt()
+            )
+            self._initialized = True
+            logger.info(f"GeminiProvider: Model initialized ({self.model_name})")
+        except Exception as e:
+            logger.error(f"GeminiProvider: Failed to initialize: {e}")
+            self.api_available = False
+            self.model = None
+
+    def is_available(self) -> bool:
+        return self.api_available
+
+    def get_status(self) -> str:
+        if self.api_available:
+            return f"✅ Connected - Model: {self.model_name}"
+        return "⚠️ Not configured (add GOOGLE_API_KEY)"
+
+    def get_provider_name(self) -> str:
+        return "Gemini (Google)"
+
+    def get_model_name(self) -> str:
+        return self.model_name if self.api_available else "gemini-2.0-flash"
+
+    def process_message(
+        self,
+        user_message: str,
+        conversation
+    ) -> Tuple[str, List[Dict]]:
+        """Process user message with Gemini"""
+        if not self.api_available:
+            return self._handle_no_api(), []
+
+        # Lazy initialization on first use
+        self._ensure_initialized()
+
+        if not self._initialized:
+            return "⚠️ Failed to initialize Gemini model. Please check your API key and try again.", []
+
+        try:
+            # Build conversation history for Gemini
+            chat = self.model.start_chat(history=self._convert_history(conversation))
+
+            # Send message and get response
+            response = chat.send_message(
+                user_message,
+                safety_settings={
+                    HarmCategory.HARM_CATEGORY_HATE_SPEECH: HarmBlockThreshold.BLOCK_NONE,
+                    HarmCategory.HARM_CATEGORY_HARASSMENT: HarmBlockThreshold.BLOCK_NONE,
+                    HarmCategory.HARM_CATEGORY_SEXUALLY_EXPLICIT: HarmBlockThreshold.BLOCK_NONE,
+                    HarmCategory.HARM_CATEGORY_DANGEROUS_CONTENT: HarmBlockThreshold.BLOCK_NONE,
+                }
+            )
+
+            # Add user message to conversation
+            conversation.add_message("user", user_message)
+
+            # Process response and handle function calls
+            return self._process_response(response, conversation, chat)
+
+        except Exception as e:
+            error_msg = f"⚠️ Gemini API error: {str(e)}"
+            logger.error(f"Gemini provider error: {e}")
+            return error_msg, []
+
+    def _convert_history(self, conversation) -> list:
+        """Convert conversation history to Gemini format"""
+        history = []
+        # Get all messages from conversation (history is built before adding current message)
+        for msg in conversation.get_history():
+            role = "user" if msg["role"] == "user" else "model"
+            history.append({
+                "role": role,
+                "parts": [{"text": str(msg["content"])}]
+            })
+        return history
+
+    def _process_response(
+        self,
+        response,
+        conversation,
+        chat
+    ) -> Tuple[str, List[Dict]]:
+        """Process Gemini's response and handle function calls"""
+        tool_calls_made = []
+
+        # Check if Gemini wants to call functions
+        try:
+            # Check ALL parts for function calls (not just first)
+            has_function_call = False
+            parts = response.candidates[0].content.parts
+            logger.info(f"Processing response with {len(parts)} part(s)")
+
+            for part in parts:
+                if hasattr(part, 'function_call'):
+                    fc = part.function_call
+                    # More robust check
+                    if fc is not None:
+                        try:
+                            if hasattr(fc, 'name') and fc.name:
+                                has_function_call = True
+                                logger.info(f"Detected function call: {fc.name}")
+                                break
+                        except Exception as e:
+                            logger.warning(f"Error checking function call: {e}")
+
+            if has_function_call:
+                # Handle function calls (potentially multiple in sequence)
+                current_response = response
+                max_iterations = 10  # Allow more iterations for complex tasks
+
+                for iteration in range(max_iterations):
+                    # Check if current response has a function call
+                    try:
+                        parts = current_response.candidates[0].content.parts
+                        logger.info(f"Iteration {iteration + 1}: Response has {len(parts)} part(s)")
+                    except (IndexError, AttributeError) as e:
+                        logger.error(f"Cannot access response parts: {e}")
+                        break
+
+                    # Check ALL parts for function calls (some responses have text + function_call)
+                    has_fc = False
+                    fc_part = None
+
+                    for idx, part in enumerate(parts):
+                        if hasattr(part, 'function_call'):
+                            fc = part.function_call
+                            if fc and hasattr(fc, 'name') and fc.name:
+                                has_fc = True
+                                fc_part = part
+                                logger.info(f"Iteration {iteration + 1}: Found function_call in part {idx}: {fc.name}")
+                                break
+
+                        # Also check if there's text (indicates Gemini wants to respond instead of continuing)
+                        if hasattr(part, 'text') and part.text:
+                            logger.warning(f"Iteration {iteration + 1}: Part {idx} has text: {part.text[:100]}")
+
+                    if not has_fc:
+                        # No more function calls, break and extract text
+                        logger.info(f"No more function calls after iteration {iteration + 1}")
+                        break
+
+                    # Use the part with function_call
+                    first_part = fc_part
+
+                    # Extract function call details
+                    function_call = first_part.function_call
+                    function_name = function_call.name
+                    function_args = dict(function_call.args) if function_call.args else {}
+
+                    logger.info(f"Gemini executing function: {function_name} (iteration {iteration + 1})")
+
+                    # Execute the tool
+                    tool_result = execute_tool(function_name, function_args)
+
+                    # Track for transparency
+                    tool_calls_made.append({
+                        "tool": function_name,
+                        "input": function_args,
+                        "result": tool_result
+                    })
+
+                    conversation.add_tool_result(function_name, function_args, tool_result)
+
+                    # Send function result back to Gemini
+                    try:
+                        current_response = chat.send_message(
+                            genai.protos.Content(
+                                parts=[genai.protos.Part(
+                                    function_response=genai.protos.FunctionResponse(
+                                        name=function_name,
+                                        response={"result": tool_result}
+                                    )
+                                )]
+                            )
+                        )
+                    except Exception as e:
+                        logger.error(f"Error sending function response: {e}")
+                        break
+
+                # Now extract text from the final response
+                # NEVER use .text property directly - always check parts
+                final_text = ""
+                try:
+                    parts = current_response.candidates[0].content.parts
+                    logger.info(f"Extracting text from {len(parts)} parts")
+
+                    for idx, part in enumerate(parts):
+                        # Check if this part has a function call
+                        if hasattr(part, 'function_call') and part.function_call:
+                            fc = part.function_call
+                            if hasattr(fc, 'name') and fc.name:
+                                logger.warning(f"Part {idx} still has function call: {fc.name}. Skipping.")
+                                continue
+
+                        # Extract text from this part
+                        if hasattr(part, 'text') and part.text:
+                            logger.info(f"Part {idx} has text: {part.text[:50]}...")
+                            final_text += part.text
+
+                except (AttributeError, IndexError) as e:
+                    logger.error(f"Error extracting text from parts: {e}")
+
+                # Generate fallback message if still no text
+                if not final_text:
+                    logger.warning("No text extracted from response, generating fallback")
+                    if tool_calls_made:
+                        # Create a summary of what was done
+                        tool_names = [t["tool"] for t in tool_calls_made]
+                        if "create_order" in tool_names:
+                            # Check if order was created successfully
+                            create_result = next((t["result"] for t in tool_calls_made if t["tool"] == "create_order"), {})
+                            if create_result.get("success"):
+                                order_id = create_result.get("order_id", "")
+                                final_text = f"✅ Order {order_id} created successfully!"
+                            else:
+                                final_text = "⚠️ There was an issue creating the order."
+                        else:
+                            final_text = f"✅ Executed {len(tool_calls_made)} tool(s) successfully!"
+                    else:
+                        final_text = "✅ Task completed!"
+
+                logger.info(f"Returning response: {final_text[:100]}")
+                conversation.add_message("assistant", final_text)
+                return final_text, tool_calls_made
+
+            else:
+                # No function call detected, extract text from parts
+                text_response = ""
+                try:
+                    parts = response.candidates[0].content.parts
+                    logger.info(f"Extracting text from {len(parts)} parts (no function call)")
+
+                    for idx, part in enumerate(parts):
+                        # Double-check no function call in this part
+                        if hasattr(part, 'function_call') and part.function_call:
+                            fc = part.function_call
+                            if hasattr(fc, 'name') and fc.name:
+                                logger.error(f"Part {idx} has function call {fc.name} but was not detected earlier!")
+                                # We missed a function call - handle it now
+                                logger.info("Re-processing response with function call handling")
+                                return self._process_response(response, conversation, chat)
+
+                        # Extract text
+                        if hasattr(part, 'text') and part.text:
+                            logger.info(f"Part {idx} has text: {part.text[:50]}...")
+                            text_response += part.text
+
+                except (ValueError, AttributeError, IndexError) as e:
+                    logger.error(f"Error extracting text from response: {e}")
+
+                # Fallback if no text extracted
+                if not text_response:
+                    logger.warning("No text in response, using fallback")
+                    text_response = "I'm ready to help! What would you like me to do?"
+
+                conversation.add_message("assistant", text_response)
+                return text_response, tool_calls_made
+
+        except Exception as e:
+            logger.error(f"Error processing Gemini response: {e}")
+            error_msg = f"⚠️ Error processing response: {str(e)}"
+            conversation.add_message("assistant", error_msg)
+            return error_msg, tool_calls_made
+
+    def _handle_no_api(self) -> str:
+        """Return error message when API is not available"""
+        return """⚠️ **Gemini API requires Google API key**
+
+To use Gemini:
+
+1. Get an API key from: https://aistudio.google.com/app/apikey
+   - Free tier: 15 requests/min, 1500/day
+   - Or use hackathon credits
+
+2. Add to your `.env` file:
+   ```
+   GOOGLE_API_KEY=your-gemini-key-here
+   ```
+
+3. Restart the application
+
+**Alternative:** Switch to Claude by setting `AI_PROVIDER=anthropic` in .env
+"""
+
+    def get_welcome_message(self) -> str:
+        if not self.api_available:
+            return self._handle_no_api()
+
+        # Initialize on first use (welcome message)
+        self._ensure_initialized()
+
+        return """👋 Hello! I'm your AI dispatch assistant powered by **Google Gemini 2.0 Flash**.
+
+I can help you manage your delivery fleet!
+
+---
+
+📋 **What I Can Do:**
+
+**1. Create Delivery Orders:**
+• Customer Name
+• Delivery Address
+• Contact (Phone OR Email)
+• Optional: Deadline, Priority, Special Instructions
+
+**2. Add New Drivers:**
+• Driver Name (required)
+• Optional: Phone, Email, Vehicle Type, License Plate, Skills
+
+---
+
+**Examples - Just Type Naturally:**
+
+📦 **Orders:**
+💬 "Create order for John Doe, 123 Main St San Francisco CA, phone 555-1234, deliver by 5 PM"
+💬 "New urgent delivery to Sarah at 456 Oak Ave NYC, email sarah@email.com"
+
+🚚 **Drivers:**
+💬 "Add new driver Tom Wilson, phone 555-0101, drives a van, plate ABC-123"
+💬 "Create driver Sarah Martinez with refrigerated truck, phone 555-0202"
+💬 "New driver: Mike Chen, email mike@fleet.com, motorcycle delivery"
+
+---
+
+🚀 **I'll automatically:**
+• Geocode addresses for orders
+• Generate unique IDs
+• Save everything to the database
+
+What would you like to do?"""

chat/route_optimizer.py

@@ -1,196 +0,0 @@
-"""
-Intelligent Route Optimizer for FleetMind
-Combines traffic, weather, and vehicle type for optimal routing decisions
-"""
-
-import logging
-from typing import Dict, List, Optional
-from chat.tools import handle_calculate_route, geocoding_service
-from chat.weather import weather_service
-
-logger = logging.getLogger(__name__)
-
-
-def calculate_intelligent_route(
-    origin: str,
-    destination: str,
-    vehicle_type: str = "car",
-    consider_weather: bool = True,
-    consider_traffic: bool = True
-) -> Dict:
-    """
-    Calculate optimal route considering traffic, weather, and vehicle type
-
-    Args:
-        origin: Starting location (address or coordinates)
-        destination: Ending location (address or coordinates)
-        vehicle_type: Type of vehicle (motorcycle, car, van, truck)
-        consider_weather: Whether to factor in weather conditions
-        consider_traffic: Whether to factor in traffic conditions
-
-    Returns:
-        Comprehensive routing result with recommendations and warnings
-    """
-    logger.info(f"Intelligent routing: {origin} → {destination} (vehicle: {vehicle_type})")
-
-    # Step 1: Calculate base route with traffic data
-    route_result = handle_calculate_route({
-        "origin": origin,
-        "destination": destination,
-        "vehicle_type": vehicle_type,
-        "alternatives": True  # Get alternative routes
-    })
-
-    if not route_result.get("success"):
-        return route_result  # Return error
-
-    # Step 2: Get weather data for the destination area
-    weather_data = None
-    weather_impact = None
-
-    if consider_weather:
-        try:
-            # Geocode destination to get coordinates
-            dest_geocoded = geocoding_service.geocode(destination)
-            dest_lat = dest_geocoded["lat"]
-            dest_lng = dest_geocoded["lng"]
-
-            # Get current weather
-            weather_data = weather_service.get_current_weather(dest_lat, dest_lng)
-
-            # Assess weather impact for this vehicle type
-            weather_impact = weather_service.assess_weather_impact(weather_data, vehicle_type)
-
-            logger.info(f"Weather impact: {weather_impact['severity']} (multiplier: {weather_impact['speed_multiplier']}x)")
-        except Exception as e:
-            logger.warning(f"Weather data unavailable: {e}")
-            consider_weather = False
-
-    # Step 3: Calculate adjusted duration
-    base_duration = route_result["duration"]["seconds"]
-    traffic_duration = route_result["duration_in_traffic"]["seconds"]
-
-    # Start with traffic-aware duration
-    adjusted_duration = traffic_duration
-
-    # Apply weather adjustments if available
-    if consider_weather and weather_impact:
-        adjusted_duration = int(adjusted_duration * weather_impact["speed_multiplier"])
-
-    # Calculate delay percentages
-    traffic_delay_percent = 0
-    weather_delay_percent = 0
-
-    if consider_traffic and traffic_duration > base_duration:
-        traffic_delay_percent = int(((traffic_duration - base_duration) / base_duration) * 100)
-
-    if consider_weather and weather_impact and weather_impact["speed_multiplier"] > 1.0:
-        weather_delay_percent = int(((weather_impact["speed_multiplier"] - 1.0) * 100))
-
-    total_delay_percent = int(((adjusted_duration - base_duration) / base_duration) * 100) if base_duration > 0 else 0
-
-    # Step 4: Generate traffic status
-    traffic_status = "unknown"
-    if consider_traffic:
-        if traffic_delay_percent == 0:
-            traffic_status = "clear"
-        elif traffic_delay_percent < 15:
-            traffic_status = "light"
-        elif traffic_delay_percent < 30:
-            traffic_status = "moderate"
-        elif traffic_delay_percent < 50:
-            traffic_status = "heavy"
-        else:
-            traffic_status = "severe"
-
-    # Step 5: Generate recommendations and warnings
-    recommendations = []
-    warnings = []
-
-    # Traffic recommendations
-    if consider_traffic:
-        if traffic_delay_percent > 30:
-            recommendations.append(f"🚦 Heavy traffic: {traffic_delay_percent}% delay - consider alternate route or timing")
-        elif traffic_delay_percent > 15:
-            recommendations.append(f"🚦 Moderate traffic: {traffic_delay_percent}% delay expected")
-
-    # Weather recommendations
-    if consider_weather and weather_impact:
-        if weather_impact["warnings"]:
-            warnings.extend(weather_impact["warnings"])
-
-        if weather_impact["recommend_delay"]:
-            recommendations.append("⚠️ SEVERE WEATHER: Consider delaying trip until conditions improve")
-
-        if vehicle_type == "motorcycle" and not weather_impact["safe_for_motorcycle"]:
-            warnings.append("🏍️ WARNING: Current weather not safe for motorcycle - consider alternative vehicle")
-
-    # Vehicle-specific recommendations
-    if vehicle_type == "motorcycle":
-        if traffic_delay_percent > 40:
-            recommendations.append("🏍️ TIP: Motorcycles can navigate heavy traffic more efficiently")
-
-    # Format durations
-    def format_duration(seconds):
-        hours = seconds // 3600
-        minutes = (seconds % 3600) // 60
-        if hours > 0:
-            return f"{hours}h {minutes}m"
-        return f"{minutes}m"
-
-    # Step 6: Build comprehensive response
-    response = {
-        "success": True,
-        "route": {
-            "origin": route_result["origin"],
-            "destination": route_result["destination"],
-            "distance": route_result["distance"],
-            "vehicle_type": vehicle_type,
-            "route_summary": route_result["route_summary"],
-            "confidence": route_result["confidence"]
-        },
-        "timing": {
-            "base_duration": {
-                "seconds": base_duration,
-                "text": format_duration(base_duration)
-            },
-            "with_traffic": {
-                "seconds": traffic_duration,
-                "text": format_duration(traffic_duration)
-            },
-            "adjusted_duration": {
-                "seconds": adjusted_duration,
-                "text": format_duration(adjusted_duration)
-            },
-            "traffic_delay_percent": traffic_delay_percent,
-            "weather_delay_percent": weather_delay_percent,
-            "total_delay_percent": total_delay_percent
-        },
-        "conditions": {
-            "traffic_status": traffic_status,
-            "traffic_considered": consider_traffic,
-            "weather_considered": consider_weather
-        },
-        "recommendations": recommendations,
-        "warnings": warnings
-    }
-
-    # Add weather data if available
-    if weather_data:
-        response["weather"] = {
-            "conditions": weather_data["conditions"],
-            "description": weather_data["description"],
-            "temperature_c": round(weather_data["temperature_c"], 1),
-            "precipitation_mm": round(weather_data["precipitation_mm"], 1),
-            "visibility_m": weather_data["visibility_m"],
-            "impact_severity": weather_impact["severity"] if weather_impact else "none"
-        }
-
-    # Add alternative routes if available
-    if route_result.get("alternatives"):
-        response["alternatives"] = route_result["alternatives"]
-        response["alternatives_count"] = len(route_result["alternatives"])
-
-    logger.info(f"Intelligent route calculated: {format_duration(adjusted_duration)} (base: {format_duration(base_duration)})")
-
-    return response

chat/weather.py

@@ -1,248 +0,0 @@
-"""
-Weather service for FleetMind
-Provides weather data for intelligent routing decisions
-"""
-
-import os
-import logging
-import requests
-from typing import Dict, Optional
-from datetime import datetime
-
-logger = logging.getLogger(__name__)
-
-
-class WeatherService:
-    """Handle weather data fetching with OpenWeatherMap API and mock fallback"""
-
-    def __init__(self):
-        self.api_key = os.getenv("OPENWEATHERMAP_API_KEY", "")
-        self.use_mock = not self.api_key or self.api_key.startswith("your_")
-        self.base_url = "https://api.openweathermap.org/data/2.5/weather"
-
-        if self.use_mock:
-            logger.info("Weather Service: Using mock (OPENWEATHERMAP_API_KEY not configured)")
-        else:
-            logger.info("Weather Service: Using OpenWeatherMap API")
-
-    def get_current_weather(self, lat: float, lng: float) -> Dict:
-        """
-        Get current weather conditions at specified coordinates
-
-        Args:
-            lat: Latitude
-            lng: Longitude
-
-        Returns:
-            Dict with weather data: temp, conditions, precipitation, visibility, wind
-        """
-        if self.use_mock:
-            return self._get_weather_mock(lat, lng)
-        else:
-            try:
-                return self._get_weather_openweathermap(lat, lng)
-            except Exception as e:
-                logger.error(f"OpenWeatherMap API failed: {e}, falling back to mock")
-                return self._get_weather_mock(lat, lng)
-
-    def _get_weather_openweathermap(self, lat: float, lng: float) -> Dict:
-        """Fetch weather from OpenWeatherMap API"""
-        try:
-            params = {
-                "lat": lat,
-                "lon": lng,
-                "appid": self.api_key,
-                "units": "metric"  # Celsius, km/h
-            }
-
-            response = requests.get(self.base_url, params=params, timeout=5)
-            response.raise_for_status()
-            data = response.json()
-
-            # Extract weather information
-            main = data.get("main", {})
-            weather = data.get("weather", [{}])[0]
-            wind = data.get("wind", {})
-            rain = data.get("rain", {})
-            snow = data.get("snow", {})
-            visibility = data.get("visibility", 10000)  # Default 10km
-
-            # Calculate precipitation (rain + snow in last hour)
-            precipitation_mm = rain.get("1h", 0) + snow.get("1h", 0)
-
-            weather_data = {
-                "temperature_c": main.get("temp", 20),
-                "feels_like_c": main.get("feels_like", 20),
-                "humidity_percent": main.get("humidity", 50),
-                "conditions": weather.get("main", "Clear"),
-                "description": weather.get("description", "clear sky"),
-                "precipitation_mm": precipitation_mm,
-                "visibility_m": visibility,
-                "wind_speed_mps": wind.get("speed", 0),
-                "wind_gust_mps": wind.get("gust", 0),
-                "timestamp": datetime.now().isoformat(),
-                "source": "OpenWeatherMap API"
-            }
-
-            logger.info(f"Weather fetched: {weather_data['conditions']}, {weather_data['temperature_c']}°C")
-            return weather_data
-
-        except Exception as e:
-            logger.error(f"OpenWeatherMap API error: {e}")
-            raise
-
-    def _get_weather_mock(self, lat: float, lng: float) -> Dict:
-        """Mock weather data for testing"""
-        # Generate pseudo-random but realistic weather based on coordinates
-        import random
-        random.seed(int(lat * 1000) + int(lng * 1000))
-
-        conditions_options = ["Clear", "Clouds", "Rain", "Drizzle", "Fog"]
-        weights = [0.5, 0.3, 0.15, 0.03, 0.02]  # Mostly clear/cloudy
-        conditions = random.choices(conditions_options, weights=weights)[0]
-
-        if conditions == "Clear":
-            precipitation_mm = 0
-            visibility_m = 10000
-            description = "clear sky"
-        elif conditions == "Clouds":
-            precipitation_mm = 0
-            visibility_m = 8000
-            description = "scattered clouds"
-        elif conditions == "Rain":
-            precipitation_mm = random.uniform(2, 10)
-            visibility_m = random.randint(5000, 8000)
-            description = "moderate rain"
-        elif conditions == "Drizzle":
-            precipitation_mm = random.uniform(0.5, 2)
-            visibility_m = random.randint(6000, 9000)
-            description = "light rain"
-        else:  # Fog
-            precipitation_mm = 0
-            visibility_m = random.randint(500, 2000)
-            description = "foggy"
-
-        weather_data = {
-            "temperature_c": random.uniform(10, 25),
-            "feels_like_c": random.uniform(8, 23),
-            "humidity_percent": random.randint(40, 80),
-            "conditions": conditions,
-            "description": description,
-            "precipitation_mm": precipitation_mm,
-            "visibility_m": visibility_m,
-            "wind_speed_mps": random.uniform(0, 8),
-            "wind_gust_mps": random.uniform(0, 12),
-            "timestamp": datetime.now().isoformat(),
-            "source": "Mock (testing)"
-        }
-
-        logger.info(f"Mock weather: {conditions}, {weather_data['temperature_c']:.1f}°C")
-        return weather_data
-
-    def assess_weather_impact(self, weather_data: Dict, vehicle_type: str = "car") -> Dict:
-        """
-        Assess how weather affects routing for a given vehicle type
-
-        Args:
-            weather_data: Weather data from get_current_weather()
-            vehicle_type: Type of vehicle (car, van, truck, motorcycle)
-
-        Returns:
-            Dict with impact assessment and warnings
-        """
-        precipitation = weather_data.get("precipitation_mm", 0)
-        visibility = weather_data.get("visibility_m", 10000)
-        wind_speed = weather_data.get("wind_speed_mps", 0)
-        conditions = weather_data.get("conditions", "Clear")
-
-        impact_score = 0  # 0 = no impact, 1 = severe impact
-        speed_multiplier = 1.0  # 1.0 = no change, 1.5 = 50% slower
-        warnings = []
-        severity = "none"
-
-        # Precipitation impact
-        if precipitation > 10:  # Heavy rain (>10mm/h)
-            impact_score += 0.6
-            speed_multiplier *= 1.4
-            warnings.append("⚠️ Heavy rain - significantly reduced speeds")
-            severity = "severe"
-
-            if vehicle_type == "motorcycle":
-                speed_multiplier *= 1.2  # Additional 20% slower for motorcycles
-                warnings.append("🏍️ DANGER: Motorcycle in heavy rain - consider rescheduling")
-
-        elif precipitation > 5:  # Moderate rain (5-10mm/h)
-            impact_score += 0.3
-            speed_multiplier *= 1.2
-            warnings.append("🌧️ Moderate rain - reduced speeds")
-            severity = "moderate"
-
-            if vehicle_type == "motorcycle":
-                speed_multiplier *= 1.15
-                warnings.append("🏍️ Caution: Wet roads for motorcycle")
-
-        elif precipitation > 0:  # Light rain
-            impact_score += 0.1
-            speed_multiplier *= 1.1
-            if vehicle_type == "motorcycle":
-                warnings.append("🏍️ Light rain - exercise caution")
-            severity = "minor"
-
-        # Visibility impact
-        if visibility < 1000:  # Poor visibility (<1km)
-            impact_score += 0.5
-            speed_multiplier *= 1.3
-            warnings.append("🌫️ Poor visibility - drive carefully")
-            if severity == "none":
-                severity = "moderate"
-
-        elif visibility < 5000:  # Reduced visibility
-            impact_score += 0.2
-            speed_multiplier *= 1.1
-            if severity == "none":
-                severity = "minor"
-
-        # Wind impact (mainly for motorcycles and high-profile vehicles)
-        if wind_speed > 15:  # Strong wind (>54 km/h)
-            if vehicle_type in ["motorcycle", "truck"]:
-                impact_score += 0.3
-                speed_multiplier *= 1.15
-                warnings.append(f"💨 Strong winds - affects {vehicle_type}")
-                if severity == "none":
-                    severity = "moderate"
-
-        # Extreme conditions
-        if conditions == "Thunderstorm":
-            impact_score += 0.8
-            speed_multiplier *= 1.6
-            warnings.append("⛈️ SEVERE: Thunderstorm - consider delaying trip")
-            severity = "severe"
-
-        if conditions == "Snow":
-            impact_score += 0.7
-            speed_multiplier *= 1.5
-            warnings.append("❄️ Snow conditions - significantly reduced speeds")
-            severity = "severe"
-
-        # Cap impact score at 1.0
-        impact_score = min(impact_score, 1.0)
-
-        return {
-            "impact_score": round(impact_score, 2),
-            "speed_multiplier": round(speed_multiplier, 2),
-            "severity": severity,
-            "warnings": warnings,
-            "safe_for_motorcycle": precipitation < 5 and visibility > 3000 and wind_speed < 12,
-            "recommend_delay": severity == "severe"
-        }
-
-    def get_status(self) -> str:
-        """Get weather service status"""
-        if self.use_mock:
-            return "⚠️ Mock weather service (configure OPENWEATHERMAP_API_KEY)"
-        else:
-            return "✅ OpenWeatherMap API connected"
-
-
-# Global weather service instance
-weather_service = WeatherService()

database/api_keys.py

@@ -1,265 +0,0 @@
-"""
-API Key Authentication System for FleetMind MCP Server
-
-Simple API key management for multi-tenant authentication without OAuth complexity.
-Works with Claude Desktop and mcp-remote today!
-
-Usage:
-    1. User generates API key via web interface or CLI
-    2. User adds API key to Claude Desktop config
-    3. MCP server validates key and returns user_id
-    4. Multi-tenant isolation works automatically
-"""
-
-import os
-import secrets
-import hashlib
-from datetime import datetime
-from typing import Optional, Dict
-from database.connection import get_db_connection
-
-def create_api_keys_table():
-    """Create api_keys table if it doesn't exist"""
-    conn = get_db_connection()
-    cursor = conn.cursor()
-
-    cursor.execute("""
-        CREATE TABLE IF NOT EXISTS api_keys (
-            key_id SERIAL PRIMARY KEY,
-            user_id VARCHAR(100) NOT NULL,
-            email VARCHAR(255) NOT NULL,
-            name VARCHAR(255),
-            api_key_hash VARCHAR(64) NOT NULL UNIQUE,
-            api_key_prefix VARCHAR(20) NOT NULL,
-            created_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-            last_used_at TIMESTAMP,
-            is_active BOOLEAN DEFAULT true,
-            UNIQUE(user_id)
-        )
-    """)
-
-    cursor.execute("""
-        CREATE INDEX IF NOT EXISTS idx_api_keys_hash
-        ON api_keys(api_key_hash)
-    """)
-
-    cursor.execute("""
-        CREATE INDEX IF NOT EXISTS idx_api_keys_user
-        ON api_keys(user_id)
-    """)
-
-    conn.commit()
-    cursor.close()
-    conn.close()
-
-def generate_api_key(email: str, name: str = None) -> Dict[str, str]:
-    """
-    Generate a new API key for a user
-
-    Args:
-        email: User's email address (used as identifier)
-        name: User's display name (optional)
-
-    Returns:
-        dict with api_key (show once!), user_id, email, name
-    """
-    # Generate secure random API key
-    api_key = f"fm_{secrets.token_urlsafe(32)}"  # fm_ prefix for FleetMind
-
-    # Hash the API key for storage (never store plain text!)
-    api_key_hash = hashlib.sha256(api_key.encode()).hexdigest()
-
-    # Store prefix for display (first 12 chars)
-    api_key_prefix = api_key[:12]
-
-    # Generate user_id from email
-    user_id = f"user_{hashlib.md5(email.encode()).hexdigest()[:12]}"
-
-    conn = get_db_connection()
-    cursor = conn.cursor()
-
-    try:
-        # Check if user already has a key
-        cursor.execute("SELECT user_id FROM api_keys WHERE email = %s", (email,))
-        existing = cursor.fetchone()
-
-        if existing:
-            cursor.close()
-            conn.close()
-            return {
-                "success": False,
-                "error": "User already has an API key. Revoke the old key first."
-            }
-
-        # Insert new API key
-        cursor.execute("""
-            INSERT INTO api_keys (user_id, email, name, api_key_hash, api_key_prefix)
-            VALUES (%s, %s, %s, %s, %s)
-            RETURNING user_id, email, name, created_at
-        """, (user_id, email, name, api_key_hash, api_key_prefix))
-
-        result = cursor.fetchone()
-        conn.commit()
-
-        if not result:
-            raise Exception("Failed to insert API key")
-
-        # Unpack the result tuple
-        ret_user_id, ret_email, ret_name, ret_created_at = result
-
-        return {
-            "success": True,
-            "api_key": api_key,  # SHOW THIS ONCE! Never displayed again
-            "user_id": ret_user_id,
-            "email": ret_email,
-            "name": ret_name or "FleetMind User",
-            "created_at": str(ret_created_at) if ret_created_at else "",
-            "message": "⚠️ IMPORTANT: Save this API key now! It won't be shown again."
-        }
-
-    except Exception as e:
-        conn.rollback()
-        import traceback
-        error_details = traceback.format_exc()
-        print(f"API Key Generation Error: {e}")
-        print(f"Error details: {error_details}")
-        return {
-            "success": False,
-            "error": f"Failed to generate API key: {str(e)}"
-        }
-    finally:
-        cursor.close()
-        conn.close()
-
-def verify_api_key(api_key: str) -> Optional[Dict[str, str]]:
-    """
-    Verify API key and return user info
-
-    Args:
-        api_key: The API key to verify
-
-    Returns:
-        User info dict if valid, None if invalid
-    """
-    if not api_key or not api_key.startswith("fm_"):
-        return None
-
-    # Hash the provided key
-    api_key_hash = hashlib.sha256(api_key.encode()).hexdigest()
-
-    conn = get_db_connection()
-    cursor = conn.cursor()
-
-    try:
-        # Look up the key
-        cursor.execute("""
-            SELECT user_id, email, name, is_active
-            FROM api_keys
-            WHERE api_key_hash = %s
-        """, (api_key_hash,))
-
-        result = cursor.fetchone()
-
-        if not result:
-            return None
-
-        # Access RealDictRow fields by key (not tuple unpacking!)
-        user_id = result['user_id']
-        email = result['email']
-        name = result['name']
-        is_active = result['is_active']
-
-        if not is_active:
-            return None
-
-        # Update last_used_at
-        cursor.execute("""
-            UPDATE api_keys
-            SET last_used_at = CURRENT_TIMESTAMP
-            WHERE api_key_hash = %s
-        """, (api_key_hash,))
-        conn.commit()
-
-        return {
-            'user_id': user_id,
-            'email': email,
-            'name': name or 'FleetMind User',
-            'scopes': ['orders:read', 'orders:write', 'drivers:read', 'drivers:write', 'assignments:manage']
-        }
-
-    except Exception as e:
-        print(f"API key verification error: {e}")
-        return None
-    finally:
-        cursor.close()
-        conn.close()
-
-def list_api_keys() -> list:
-    """List all API keys (without showing actual keys)"""
-    conn = get_db_connection()
-    cursor = conn.cursor()
-
-    cursor.execute("""
-        SELECT user_id, email, name, api_key_prefix, created_at, last_used_at, is_active
-        FROM api_keys
-        ORDER BY created_at DESC
-    """)
-
-    keys = []
-    for row in cursor.fetchall():
-        keys.append({
-            'user_id': row[0],
-            'email': row[1],
-            'name': row[2],
-            'key_preview': f"{row[3]}...",
-            'created_at': row[4].isoformat(),
-            'last_used_at': row[5].isoformat() if row[5] else None,
-            'is_active': row[6]
-        })
-
-    cursor.close()
-    conn.close()
-    return keys
-
-def revoke_api_key(email: str) -> Dict[str, any]:
-    """Revoke (deactivate) an API key"""
-    conn = get_db_connection()
-    cursor = conn.cursor()
-
-    try:
-        cursor.execute("""
-            UPDATE api_keys
-            SET is_active = false
-            WHERE email = %s
-            RETURNING user_id, email
-        """, (email,))
-
-        result = cursor.fetchone()
-        conn.commit()
-
-        if result:
-            return {
-                "success": True,
-                "message": f"API key revoked for {result[1]}"
-            }
-        else:
-            return {
-                "success": False,
-                "error": "No API key found for this email"
-            }
-
-    except Exception as e:
-        conn.rollback()
-        return {
-            "success": False,
-            "error": f"Failed to revoke key: {str(e)}"
-        }
-    finally:
-        cursor.close()
-        conn.close()
-
-# Initialize table on import
-try:
-    create_api_keys_table()
-except:
-    pass  # Table might already exist

database/connection.py

@@ -45,8 +45,7 @@ def get_db_connection() -> psycopg2.extensions.connection:
             database=DB_CONFIG['database'],
             user=DB_CONFIG['user'],
             password=DB_CONFIG['password'],
-            cursor_factory=psycopg2.extras.RealDictCursor,
-            sslmode='prefer'
+            cursor_factory=psycopg2.extras.RealDictCursor
         )
 
         logger.info(f"Database connection established: {DB_CONFIG['database']}@{DB_CONFIG['host']}")

database/migrations/002_create_assignments_table.py

@@ -1,157 +0,0 @@
-"""
-Migration 002: Create Assignments Table
-Creates the assignments table for managing order-driver assignments with route data
-"""
-
-import sys
-import os
-
-# Add parent directory to path for imports
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
-
-from database.connection import get_db_connection
-
-MIGRATION_SQL = """
--- Create assignments table with enhanced route tracking
-CREATE TABLE IF NOT EXISTS assignments (
-    assignment_id VARCHAR(50) PRIMARY KEY,
-    order_id VARCHAR(50) NOT NULL,
-    driver_id VARCHAR(50) NOT NULL,
-
-    -- Assignment metadata
-    assigned_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    updated_at TIMESTAMP DEFAULT CURRENT_TIMESTAMP,
-    sequence_number INTEGER,
-
-    -- Route data from Google Routes API
-    route_distance_meters INTEGER,
-    route_duration_seconds INTEGER,
-    route_duration_in_traffic_seconds INTEGER,
-    route_summary TEXT,
-    route_polyline TEXT,
-
-    -- Origin/destination tracking
-    driver_start_location_lat DECIMAL(10, 8),
-    driver_start_location_lng DECIMAL(11, 8),
-    delivery_location_lat DECIMAL(10, 8),
-    delivery_location_lng DECIMAL(11, 8),
-    delivery_address TEXT,
-
-    -- Timing data
-    estimated_arrival TIMESTAMP,
-    actual_arrival TIMESTAMP,
-
-    -- Actual vs estimated tracking
-    actual_distance_meters INTEGER,
-
-    -- Vehicle context
-    vehicle_type VARCHAR(50),
-
-    -- Status management
-    status VARCHAR(20) CHECK(status IN ('active', 'in_progress', 'completed', 'cancelled', 'failed')) DEFAULT 'active',
-
-    -- Additional metadata
-    traffic_delay_seconds INTEGER,
-    weather_conditions JSONB,
-    route_confidence VARCHAR(100),
-    notes TEXT,
-
-    -- Foreign keys with proper cascade behavior
-    FOREIGN KEY (order_id) REFERENCES orders(order_id) ON DELETE CASCADE,
-    FOREIGN KEY (driver_id) REFERENCES drivers(driver_id) ON DELETE RESTRICT
-);
-
--- Create indexes for performance
-CREATE INDEX IF NOT EXISTS idx_assignments_driver ON assignments(driver_id);
-CREATE INDEX IF NOT EXISTS idx_assignments_order ON assignments(order_id);
-CREATE INDEX IF NOT EXISTS idx_assignments_status ON assignments(status);
-CREATE INDEX IF NOT EXISTS idx_assignments_assigned_at ON assignments(assigned_at);
-
--- Create trigger for auto-updating updated_at
-CREATE OR REPLACE FUNCTION update_updated_at_column()
-RETURNS TRIGGER AS $$
-BEGIN
-    NEW.updated_at = CURRENT_TIMESTAMP;
-    RETURN NEW;
-END;
-$$ LANGUAGE plpgsql;
-
-CREATE TRIGGER update_assignments_timestamp
-    BEFORE UPDATE ON assignments
-    FOR EACH ROW
-    EXECUTE FUNCTION update_updated_at_column();
-
--- Add unique constraint to prevent multiple active assignments per order
-CREATE UNIQUE INDEX IF NOT EXISTS idx_assignments_unique_active_order
-    ON assignments(order_id)
-    WHERE status IN ('active', 'in_progress');
-"""
-
-ROLLBACK_SQL = """
-DROP INDEX IF EXISTS idx_assignments_unique_active_order;
-DROP TRIGGER IF EXISTS update_assignments_timestamp ON assignments;
-DROP INDEX IF EXISTS idx_assignments_assigned_at;
-DROP INDEX IF EXISTS idx_assignments_status;
-DROP INDEX IF EXISTS idx_assignments_order;
-DROP INDEX IF EXISTS idx_assignments_driver;
-DROP TABLE IF EXISTS assignments CASCADE;
-"""
-
-
-def up():
-    """Apply migration - create assignments table"""
-    print("Running migration 002: Create assignments table...")
-
-    try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        # Execute migration SQL
-        cursor.execute(MIGRATION_SQL)
-
-        conn.commit()
-        cursor.close()
-        conn.close()
-
-        print("SUCCESS: Migration 002 applied successfully")
-        print("  - Created assignments table")
-        print("  - Created indexes (driver, order, status, assigned_at)")
-        print("  - Created update trigger")
-        print("  - Created unique constraint for active assignments per order")
-        return True
-
-    except Exception as e:
-        print(f"ERROR: Migration 002 failed: {e}")
-        return False
-
-
-def down():
-    """Rollback migration - drop assignments table"""
-    print("Rolling back migration 002: Drop assignments table...")
-
-    try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        # Execute rollback SQL
-        cursor.execute(ROLLBACK_SQL)
-
-        conn.commit()
-        cursor.close()
-        conn.close()
-
-        print("SUCCESS: Migration 002 rolled back successfully")
-        return True
-
-    except Exception as e:
-        print(f"ERROR: Migration 002 rollback failed: {e}")
-        return False
-
-
-if __name__ == "__main__":
-    import sys
-
-    if len(sys.argv) > 1 and sys.argv[1] == "down":
-        down()
-    else:
-        up()

database/migrations/003_add_order_driver_fk.py

@@ -1,88 +0,0 @@
-"""
-Migration 003: Add Foreign Key Constraint to orders.assigned_driver_id
-Adds FK constraint to ensure referential integrity between orders and drivers
-"""
-
-import sys
-import os
-
-# Add parent directory to path for imports
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
-
-from database.connection import get_db_connection
-
-MIGRATION_SQL = """
--- Add foreign key constraint to orders.assigned_driver_id
--- Use ON DELETE SET NULL so that if driver is deleted, order is not lost
--- (The assignment record will be handled separately via RESTRICT constraint)
-ALTER TABLE orders
-ADD CONSTRAINT fk_orders_assigned_driver
-FOREIGN KEY (assigned_driver_id)
-REFERENCES drivers(driver_id)
-ON DELETE SET NULL;
-"""
-
-ROLLBACK_SQL = """
--- Drop foreign key constraint
-ALTER TABLE orders
-DROP CONSTRAINT IF EXISTS fk_orders_assigned_driver;
-"""
-
-
-def up():
-    """Apply migration - add FK constraint"""
-    print("Running migration 003: Add FK constraint to orders.assigned_driver_id...")
-
-    try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        # Execute migration SQL
-        cursor.execute(MIGRATION_SQL)
-
-        conn.commit()
-        cursor.close()
-        conn.close()
-
-        print("SUCCESS: Migration 003 applied successfully")
-        print("  - Added FK constraint: orders.assigned_driver_id -> drivers.driver_id")
-        print("  - ON DELETE SET NULL (preserves order history if driver deleted)")
-        return True
-
-    except Exception as e:
-        print(f"ERROR: Migration 003 failed: {e}")
-        print("  Note: This may fail if there are existing invalid driver references")
-        print("  Clean up orphaned assigned_driver_id values before running this migration")
-        return False
-
-
-def down():
-    """Rollback migration - drop FK constraint"""
-    print("Rolling back migration 003: Drop FK constraint from orders.assigned_driver_id...")
-
-    try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        # Execute rollback SQL
-        cursor.execute(ROLLBACK_SQL)
-
-        conn.commit()
-        cursor.close()
-        conn.close()
-
-        print("SUCCESS: Migration 003 rolled back successfully")
-        return True
-
-    except Exception as e:
-        print(f"ERROR: Migration 003 rollback failed: {e}")
-        return False
-
-
-if __name__ == "__main__":
-    import sys
-
-    if len(sys.argv) > 1 and sys.argv[1] == "down":
-        down()
-    else:
-        up()

database/migrations/004_add_route_directions.py

@@ -1,84 +0,0 @@
-"""
-Migration 004: Add route_directions column to assignments table
-Adds JSONB column to store turn-by-turn navigation instructions from Google Routes API
-"""
-
-import sys
-import os
-
-# Add parent directory to path for imports
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
-
-from database.connection import get_db_connection
-
-MIGRATION_SQL = """
--- Add route_directions column to store turn-by-turn navigation steps
-ALTER TABLE assignments
-ADD COLUMN IF NOT EXISTS route_directions JSONB;
-
--- Add comment to explain the column
-COMMENT ON COLUMN assignments.route_directions IS 'Turn-by-turn navigation instructions from Google Routes API (array of steps with instructions, distance, duration)';
-"""
-
-ROLLBACK_SQL = """
--- Drop route_directions column
-ALTER TABLE assignments
-DROP COLUMN IF EXISTS route_directions;
-"""
-
-
-def up():
-    """Apply migration - add route_directions column"""
-    print("Running migration 004: Add route_directions column to assignments table...")
-
-    try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        # Execute migration SQL
-        cursor.execute(MIGRATION_SQL)
-
-        conn.commit()
-        cursor.close()
-        conn.close()
-
-        print("SUCCESS: Migration 004 applied successfully")
-        print("  - Added route_directions JSONB column to assignments table")
-        print("  - Column will store turn-by-turn navigation instructions")
-        return True
-
-    except Exception as e:
-        print(f"ERROR: Migration 004 failed: {e}")
-        return False
-
-
-def down():
-    """Rollback migration - drop route_directions column"""
-    print("Rolling back migration 004: Drop route_directions column...")
-
-    try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        # Execute rollback SQL
-        cursor.execute(ROLLBACK_SQL)
-
-        conn.commit()
-        cursor.close()
-        conn.close()
-
-        print("SUCCESS: Migration 004 rolled back successfully")
-        return True
-
-    except Exception as e:
-        print(f"ERROR: Migration 004 rollback failed: {e}")
-        return False
-
-
-if __name__ == "__main__":
-    import sys
-
-    if len(sys.argv) > 1 and sys.argv[1] == "down":
-        down()
-    else:
-        up()

database/migrations/005_add_failure_reason.py

@@ -1,98 +0,0 @@
-"""
-Migration 005: Add failure_reason column to assignments table
-Adds structured failure reason field for failed deliveries
-"""
-
-import sys
-import os
-
-# Add parent directory to path for imports
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
-
-from database.connection import get_db_connection
-
-MIGRATION_SQL = """
--- Add failure_reason column with predefined categories
-ALTER TABLE assignments
-ADD COLUMN IF NOT EXISTS failure_reason VARCHAR(100)
-CHECK(failure_reason IN (
-    'customer_not_available',
-    'wrong_address',
-    'refused_delivery',
-    'damaged_goods',
-    'payment_issue',
-    'vehicle_breakdown',
-    'access_restricted',
-    'weather_conditions',
-    'other'
-));
-
--- Add comment to explain the column
-COMMENT ON COLUMN assignments.failure_reason IS 'Structured reason for delivery failure (required when status is failed)';
-"""
-
-ROLLBACK_SQL = """
--- Drop failure_reason column
-ALTER TABLE assignments
-DROP COLUMN IF EXISTS failure_reason;
-"""
-
-
-def up():
-    """Apply migration - add failure_reason column"""
-    print("Running migration 005: Add failure_reason column to assignments table...")
-
-    try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        # Execute migration SQL
-        cursor.execute(MIGRATION_SQL)
-
-        conn.commit()
-        cursor.close()
-        conn.close()
-
-        print("SUCCESS: Migration 005 applied successfully")
-        print("  - Added failure_reason VARCHAR(100) column to assignments table")
-        print("  - Constraint added for predefined failure categories")
-        print("  - Available reasons: customer_not_available, wrong_address, refused_delivery,")
-        print("    damaged_goods, payment_issue, vehicle_breakdown, access_restricted,")
-        print("    weather_conditions, other")
-        return True
-
-    except Exception as e:
-        print(f"ERROR: Migration 005 failed: {e}")
-        return False
-
-
-def down():
-    """Rollback migration - drop failure_reason column"""
-    print("Rolling back migration 005: Drop failure_reason column...")
-
-    try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        # Execute rollback SQL
-        cursor.execute(ROLLBACK_SQL)
-
-        conn.commit()
-        cursor.close()
-        conn.close()
-
-        print("SUCCESS: Migration 005 rolled back successfully")
-        return True
-
-    except Exception as e:
-        print(f"ERROR: Migration 005 rollback failed: {e}")
-        return False
-
-
-if __name__ == "__main__":
-    import sys
-
-    if len(sys.argv) > 1 and sys.argv[1] == "down":
-        down()
-    else:
-        up()

database/migrations/006_add_delivery_timing.py

@@ -1,106 +0,0 @@
-"""
-Migration 006: Add delivery timing and SLA tracking fields to orders table
-Adds expected_delivery_time (mandatory), delivery_status, and sla_grace_period_minutes
-"""
-
-import sys
-import os
-
-# Add parent directory to path for imports
-sys.path.insert(0, os.path.dirname(os.path.dirname(os.path.dirname(os.path.abspath(__file__)))))
-
-from database.connection import get_db_connection
-
-MIGRATION_SQL = """
--- Add expected delivery time (mandatory deadline promised to customer)
-ALTER TABLE orders
-ADD COLUMN IF NOT EXISTS expected_delivery_time TIMESTAMP;
-
--- Add delivery performance status
-ALTER TABLE orders
-ADD COLUMN IF NOT EXISTS delivery_status VARCHAR(20)
-CHECK(delivery_status IN ('on_time', 'late', 'very_late', 'failed_on_time', 'failed_late'));
-
--- Add SLA grace period (minutes after expected time that's still acceptable)
-ALTER TABLE orders
-ADD COLUMN IF NOT EXISTS sla_grace_period_minutes INTEGER DEFAULT 15;
-
--- Add comments
-COMMENT ON COLUMN orders.expected_delivery_time IS 'Required delivery deadline promised to customer (mandatory when creating order)';
-COMMENT ON COLUMN orders.delivery_status IS 'Delivery performance: on_time, late (within grace), very_late (SLA violation), failed_on_time, failed_late';
-COMMENT ON COLUMN orders.sla_grace_period_minutes IS 'Grace period in minutes after expected_delivery_time (default: 15 mins)';
-
--- Create index for querying by expected delivery time
-CREATE INDEX IF NOT EXISTS idx_orders_expected_delivery ON orders(expected_delivery_time);
-"""
-
-ROLLBACK_SQL = """
--- Drop indexes
-DROP INDEX IF EXISTS idx_orders_expected_delivery;
-
--- Drop columns
-ALTER TABLE orders
-DROP COLUMN IF EXISTS expected_delivery_time,
-DROP COLUMN IF EXISTS delivery_status,
-DROP COLUMN IF EXISTS sla_grace_period_minutes;
-"""
-
-
-def up():
-    """Apply migration - add delivery timing fields"""
-    print("Running migration 006: Add delivery timing and SLA tracking fields...")
-
-    try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        # Execute migration SQL
-        cursor.execute(MIGRATION_SQL)
-
-        conn.commit()
-        cursor.close()
-        conn.close()
-
-        print("SUCCESS: Migration 006 applied successfully")
-        print("  - Added expected_delivery_time TIMESTAMP column")
-        print("  - Added delivery_status VARCHAR(20) column")
-        print("  - Added sla_grace_period_minutes INTEGER column (default: 15)")
-        print("  - Created index on expected_delivery_time")
-        print("  - Valid delivery statuses: on_time, late, very_late, failed_on_time, failed_late")
-        return True
-
-    except Exception as e:
-        print(f"ERROR: Migration 006 failed: {e}")
-        return False
-
-
-def down():
-    """Rollback migration - drop delivery timing fields"""
-    print("Rolling back migration 006: Drop delivery timing fields...")
-
-    try:
-        conn = get_db_connection()
-        cursor = conn.cursor()
-
-        # Execute rollback SQL
-        cursor.execute(ROLLBACK_SQL)
-
-        conn.commit()
-        cursor.close()
-        conn.close()
-
-        print("SUCCESS: Migration 006 rolled back successfully")
-        return True
-
-    except Exception as e:
-        print(f"ERROR: Migration 006 rollback failed: {e}")
-        return False
-
-
-if __name__ == "__main__":
-    import sys
-
-    if len(sys.argv) > 1 and sys.argv[1] == "down":
-        down()
-    else:
-        up()

database/migrations/007_add_user_id.py

@@ -1,167 +0,0 @@
-"""
-Migration 007: Add user_id columns for multi-tenant support
-
-This migration adds user_id to all tables to enable user-specific data isolation.
-Each user will only see their own orders, drivers, assignments, etc.
-"""
-
-import sys
-from pathlib import Path
-
-# Add parent directory to path
-sys.path.insert(0, str(Path(__file__).parent.parent.parent))
-
-from database.connection import execute_write
-
-
-def up():
-    """Add user_id columns and indexes"""
-
-    migrations = [
-        # Add user_id column to orders table
-        """
-        ALTER TABLE orders
-        ADD COLUMN IF NOT EXISTS user_id VARCHAR(255);
-        """,
-
-        # Add user_id column to drivers table
-        """
-        ALTER TABLE drivers
-        ADD COLUMN IF NOT EXISTS user_id VARCHAR(255);
-        """,
-
-        # Add user_id column to assignments table
-        """
-        ALTER TABLE assignments
-        ADD COLUMN IF NOT EXISTS user_id VARCHAR(255);
-        """,
-
-        # Add user_id column to exceptions table
-        """
-        ALTER TABLE exceptions
-        ADD COLUMN IF NOT EXISTS user_id VARCHAR(255);
-        """,
-
-        # Add user_id column to agent_decisions table
-        """
-        ALTER TABLE agent_decisions
-        ADD COLUMN IF NOT EXISTS user_id VARCHAR(255);
-        """,
-
-        # Add user_id column to metrics table
-        """
-        ALTER TABLE metrics
-        ADD COLUMN IF NOT EXISTS user_id VARCHAR(255);
-        """,
-
-        # Create indexes for fast user-based filtering
-        """
-        CREATE INDEX IF NOT EXISTS idx_orders_user_id ON orders(user_id);
-        """,
-
-        """
-        CREATE INDEX IF NOT EXISTS idx_drivers_user_id ON drivers(user_id);
-        """,
-
-        """
-        CREATE INDEX IF NOT EXISTS idx_assignments_user_id ON assignments(user_id);
-        """,
-
-        """
-        CREATE INDEX IF NOT EXISTS idx_exceptions_user_id ON exceptions(user_id);
-        """,
-
-        """
-        CREATE INDEX IF NOT EXISTS idx_agent_decisions_user_id ON agent_decisions(user_id);
-        """,
-
-        """
-        CREATE INDEX IF NOT EXISTS idx_metrics_user_id ON metrics(user_id);
-        """,
-
-        # Create composite indexes for common queries
-        """
-        CREATE INDEX IF NOT EXISTS idx_orders_user_status ON orders(user_id, status);
-        """,
-
-        """
-        CREATE INDEX IF NOT EXISTS idx_orders_user_created ON orders(user_id, created_at DESC);
-        """,
-
-        """
-        CREATE INDEX IF NOT EXISTS idx_drivers_user_status ON drivers(user_id, status);
-        """,
-
-        """
-        CREATE INDEX IF NOT EXISTS idx_assignments_user_driver ON assignments(user_id, driver_id);
-        """,
-
-        """
-        CREATE INDEX IF NOT EXISTS idx_assignments_user_order ON assignments(user_id, order_id);
-        """,
-    ]
-
-    print("Migration 007: Adding user_id columns...")
-
-    for i, sql in enumerate(migrations, 1):
-        try:
-            print(f"  [{i}/{len(migrations)}] Executing: {sql.strip()[:60]}...")
-            execute_write(sql)
-            print(f"  Success")
-        except Exception as e:
-            print(f"  Warning: {e}")
-            # Continue even if column already exists
-
-    print("\nMigration 007 complete!")
-    print("\nNext steps:")
-    print("  1. Existing data will have NULL user_id (that's OK for now)")
-    print("  2. New data will automatically get user_id from authentication")
-    print("  3. You can optionally run a data migration to assign existing records to a test user")
-
-
-def down():
-    """Remove user_id columns and indexes (rollback)"""
-
-    rollback_migrations = [
-        # Drop indexes first
-        "DROP INDEX IF EXISTS idx_assignments_user_order;",
-        "DROP INDEX IF EXISTS idx_assignments_user_driver;",
-        "DROP INDEX IF EXISTS idx_drivers_user_status;",
-        "DROP INDEX IF EXISTS idx_orders_user_created;",
-        "DROP INDEX IF EXISTS idx_orders_user_status;",
-        "DROP INDEX IF EXISTS idx_metrics_user_id;",
-        "DROP INDEX IF EXISTS idx_agent_decisions_user_id;",
-        "DROP INDEX IF EXISTS idx_exceptions_user_id;",
-        "DROP INDEX IF EXISTS idx_assignments_user_id;",
-        "DROP INDEX IF EXISTS idx_drivers_user_id;",
-        "DROP INDEX IF EXISTS idx_orders_user_id;",
-
-        # Drop columns
-        "ALTER TABLE metrics DROP COLUMN IF EXISTS user_id;",
-        "ALTER TABLE agent_decisions DROP COLUMN IF EXISTS user_id;",
-        "ALTER TABLE exceptions DROP COLUMN IF EXISTS user_id;",
-        "ALTER TABLE assignments DROP COLUMN IF EXISTS user_id;",
-        "ALTER TABLE drivers DROP COLUMN IF EXISTS user_id;",
-        "ALTER TABLE orders DROP COLUMN IF EXISTS user_id;",
-    ]
-
-    print("Rolling back Migration 007...")
-
-    for i, sql in enumerate(rollback_migrations, 1):
-        try:
-            print(f"  [{i}/{len(rollback_migrations)}] {sql[:60]}...")
-            execute_write(sql)
-            print(f"  Success")
-        except Exception as e:
-            print(f"  Warning: {e}")
-
-    print("\nRollback complete!")
-
-
-if __name__ == "__main__":
-    import sys
-
-    if len(sys.argv) > 1 and sys.argv[1] == "down":
-        down()
-    else:
-        up()

database/migrations/008_add_driver_address.py

@@ -1,64 +0,0 @@
-"""
-Migration 008: Add current_address field to drivers table
-This stores the address for driver locations (provided by user along with lat/lng)
-"""
-
-import sys
-from pathlib import Path
-
-# Add parent directory to path
-sys.path.insert(0, str(Path(__file__).parent.parent.parent))
-
-from database.connection import execute_write
-
-
-def up():
-    """Add current_address column to drivers table"""
-
-    migrations = [
-        """
-        ALTER TABLE drivers
-        ADD COLUMN IF NOT EXISTS current_address TEXT;
-        """,
-    ]
-
-    print("Migration 008: Adding current_address column to drivers...")
-
-    for i, sql in enumerate(migrations, 1):
-        try:
-            print(f"  [{i}/{len(migrations)}] Executing: {sql.strip()[:60]}...")
-            execute_write(sql)
-            print(f"  Success")
-        except Exception as e:
-            print(f"  Warning: {e}")
-
-    print("\nMigration 008 complete!")
-
-
-def down():
-    """Remove current_address column from drivers table"""
-
-    rollback_migrations = [
-        "ALTER TABLE drivers DROP COLUMN IF EXISTS current_address;",
-    ]
-
-    print("Rolling back Migration 008...")
-
-    for i, sql in enumerate(rollback_migrations, 1):
-        try:
-            print(f"  [{i}/{len(rollback_migrations)}] {sql[:60]}...")
-            execute_write(sql)
-            print(f"  Success")
-        except Exception as e:
-            print(f"  Warning: {e}")
-
-    print("\nRollback complete!")
-
-
-if __name__ == "__main__":
-    import sys
-
-    if len(sys.argv) > 1 and sys.argv[1] == "down":
-        down()
-    else:
-        up()

database/user_context.py

@@ -1,81 +0,0 @@
-"""
-User Context and Permission Module
-Handles permission checks for API key authentication
-"""
-
-from typing import Optional
-
-
-def check_permission(user_scopes: list, required_scope: str) -> bool:
-    """
-    Check if user has required permission
-
-    Args:
-        user_scopes: List of scopes user has
-        required_scope: Scope needed for this operation
-
-    Returns:
-        True if user has permission
-    """
-    # Admin has all permissions
-    if 'admin' in user_scopes:
-        return True
-
-    # Check specific scope
-    return required_scope in user_scopes
-
-
-# Scope requirements for each tool
-SCOPE_REQUIREMENTS = {
-    # Order operations
-    'create_order': 'orders:write',
-    'fetch_orders': 'orders:read',
-    'update_order': 'orders:write',
-    'delete_order': 'orders:write',
-    'search_orders': 'orders:read',
-    'get_order_details': 'orders:read',
-    'count_orders': 'orders:read',
-    'get_incomplete_orders': 'orders:read',
-
-    # Driver operations
-    'create_driver': 'drivers:write',
-    'fetch_drivers': 'drivers:read',
-    'update_driver': 'drivers:write',
-    'delete_driver': 'drivers:write',
-    'search_drivers': 'drivers:read',
-    'get_driver_details': 'drivers:read',
-    'count_drivers': 'drivers:read',
-    'get_available_drivers': 'drivers:read',
-
-    # Assignment operations
-    'create_assignment': 'assignments:manage',
-    'auto_assign_order': 'assignments:manage',
-    'intelligent_assign_order': 'assignments:manage',
-    'get_assignment_details': 'assignments:manage',
-    'update_assignment': 'assignments:manage',
-    'unassign_order': 'assignments:manage',
-    'complete_delivery': 'assignments:manage',
-    'fail_delivery': 'assignments:manage',
-
-    # Routing (public - no scope required)
-    'geocode_address': None,
-    'calculate_route': None,
-    'calculate_intelligent_route': None,
-
-    # Dangerous operations (admin only)
-    'delete_all_orders': 'admin',
-    'delete_all_drivers': 'admin',
-}
-
-
-def get_required_scope(tool_name: str) -> Optional[str]:
-    """
-    Get the scope required for a tool
-
-    Args:
-        tool_name: Name of the tool
-
-    Returns:
-        Required scope or None if tool is public
-    """
-    return SCOPE_REQUIREMENTS.get(tool_name, 'admin')

flow.md

@@ -0,0 +1,828 @@
+● 🔄 Complete Function Flow
+
+  Input: "Create an order for John Doe at 123 Main St, San 
+  Francisco"
+
+  Let me trace every single function call with this exact example!      
+
+  ---
+  📞 FUNCTION CALL SEQUENCE:
+
+  STEP 1: User Clicks Send Button
+
+  FILE: ui/app.py
+  LINE: 448-452
+
+  User clicks "Send" button in Gradio UI
+      ↓
+  FUNCTION CALLED: send_message(message, conv_state)
+      message = "Create an order for John Doe at 123 Main St, San       
+  Francisco"
+      conv_state = ConversationManager object
+
+  Function Code:
+  def send_message(message, conv_state):
+      """Handle send button click"""
+      chat_history, tools, new_state = handle_chat_message(message,     
+  conv_state)
+      #                                 ↑
+      #                                 CALLS THIS NEXT
+      return chat_history, tools, new_state, ""
+
+  ---
+  STEP 2: handle_chat_message()
+
+  FILE: ui/app.py
+  LINE: 223-241
+
+  FUNCTION: handle_chat_message(message, conversation_state)
+      message = "Create an order for John Doe at 123 Main St, San       
+  Francisco"
+      conversation_state = ConversationManager object
+
+  Function Code:
+  def handle_chat_message(message, conversation_state):
+      if not message.strip():
+          return ...
+
+      # Process message through chat engine
+      response, tool_calls = chat_engine.process_message(message,       
+  conversation_state)
+      #                      ↑
+      #                      CALLS THIS NEXT
+
+      # Return updated UI
+      return conversation_state.get_formatted_history(),
+  conversation_state.get_tool_calls(), conversation_state
+
+  ---
+  STEP 3: chat_engine.process_message()
+
+  FILE: chat/chat_engine.py
+  LINE: 58-73
+
+  FUNCTION: ChatEngine.process_message(user_message, conversation)      
+      user_message = "Create an order for John Doe at 123 Main St,      
+  San Francisco"
+      conversation = ConversationManager object
+
+  Function Code:
+  def process_message(self, user_message, conversation):
+      """Process user message and return AI response"""
+      return self.provider.process_message(user_message,
+  conversation)
+      #      ↑
+      #      self.provider = GeminiProvider (from chat_engine.py:26)    
+      #      CALLS GeminiProvider.process_message() NEXT
+
+  ---
+  STEP 4: GeminiProvider.process_message()
+
+  FILE: chat/providers/gemini_provider.py
+  LINE: 173-212
+
+  FUNCTION: GeminiProvider.process_message(user_message,
+  conversation)
+      user_message = "Create an order for John Doe at 123 Main St,      
+  San Francisco"
+      conversation = ConversationManager object
+
+  Function Code:
+  def process_message(self, user_message, conversation):
+      """Process user message with Gemini"""
+      if not self.api_available:
+          return self._handle_no_api(), []
+
+      # Lazy initialization on first use
+      self._ensure_initialized()  # ← CALLS THIS if not initialized     
+
+      if not self._initialized:
+          return "⚠️ Failed to initialize...", []
+
+      try:
+          # Build conversation history for Gemini
+          chat =
+  self.model.start_chat(history=self._convert_history(conversation))    
+          #                                      ↑
+          #                                      CALLS
+  _convert_history()
+
+          # Send message and get response
+          response = chat.send_message(user_message,
+  safety_settings={...})
+          #          ↑
+          #          🌐 API CALL TO GOOGLE GEMINI
+          #          Sends: "Create an order for John Doe at 123        
+  Main St, San Francisco"
+
+          # Add user message to conversation
+          conversation.add_message("user", user_message)
+
+          # Process response and handle function calls
+          return self._process_response(response, conversation,
+  chat)
+          #      ↑
+          #      CALLS THIS NEXT
+
+  ---
+  STEP 5: Gemini API Processes Request
+
+  🌐 GOOGLE GEMINI API (External)
+
+  RECEIVES:
+  - System Prompt: "You are an AI assistant for FleetMind..."
+  - User Message: "Create an order for John Doe at 123 Main St, San     
+  Francisco"
+  - Available Tools: [geocode_address, create_order]
+
+  AI ANALYZES:
+  "User wants to create an order. I have:
+   ✅ Customer Name: John Doe
+   ✅ Address: 123 Main St, San Francisco
+   ❌ GPS Coordinates: Missing!
+
+   DECISION: Call geocode_address tool first to get coordinates."       
+
+  RETURNS TO CODE:
+  response = {
+      candidates: [{
+          content: {
+              parts: [{
+                  function_call: {
+                      name: "geocode_address",
+                      args: {
+                          "address": "123 Main St, San Francisco"       
+                      }
+                  }
+              }]
+          }
+      }]
+  }
+
+  ---
+  STEP 6: _process_response() - Detects Function Call
+
+  FILE: chat/providers/gemini_provider.py
+  LINE: 226-393
+
+  FUNCTION: _process_response(response, conversation, chat)
+      response = Response from Gemini with function_call
+      conversation = ConversationManager object
+      chat = Gemini chat session
+
+  Function Code:
+  def _process_response(self, response, conversation, chat):
+      """Process Gemini's response and handle function calls"""
+      tool_calls_made = []
+
+      try:
+          # Check ALL parts for function calls
+          parts = response.candidates[0].content.parts
+          logger.info(f"Processing response with {len(parts)}
+  part(s)")
+          #            ↑
+          #            LOGS: "Processing response with 1 part(s)"       
+
+          for part in parts:
+              if hasattr(part, 'function_call'):
+                  fc = part.function_call
+                  if fc and hasattr(fc, 'name') and fc.name:
+                      has_function_call = True
+                      logger.info(f"Detected function call:
+  {fc.name}")
+                      #            ↑
+                      #            LOGS: "Detected function call:       
+  geocode_address"
+                      break
+
+          if has_function_call:
+              # Handle function calls (potentially multiple in
+  sequence)
+              current_response = response
+              max_iterations = 10
+
+              for iteration in range(max_iterations):  # ← LOOP
+  STARTS
+                  # Extract function call details
+                  first_part =
+  current_response.candidates[0].content.parts[0]
+                  function_call = first_part.function_call
+                  function_name = function_call.name  #
+  "geocode_address"
+                  function_args = dict(function_call.args)  #
+  {"address": "123 Main St, San Francisco"}
+
+                  logger.info(f"Gemini executing function:
+  {function_name} (iteration {iteration + 1})")
+                  #            ↑
+                  #            LOGS: "Gemini executing function:        
+  geocode_address (iteration 1)"
+
+                  # Execute the tool
+                  tool_result = execute_tool(function_name,
+  function_args)
+                  #             ↑
+                  #             CALLS execute_tool() NEXT
+
+  ---
+  STEP 7: execute_tool() - Routes to Handler
+
+  FILE: chat/tools.py
+  LINE: 92-118
+
+  FUNCTION: execute_tool(tool_name, tool_input)
+      tool_name = "geocode_address"
+      tool_input = {"address": "123 Main St, San Francisco"}
+
+  Function Code:
+  def execute_tool(tool_name, tool_input):
+      """Route tool execution to appropriate handler"""
+      try:
+          if tool_name == "geocode_address":
+              return handle_geocode_address(tool_input)
+              #      ↑
+              #      CALLS THIS NEXT
+          elif tool_name == "create_order":
+              return handle_create_order(tool_input)
+          else:
+              return {"success": False, "error": f"Unknown tool:        
+  {tool_name}"}
+      except Exception as e:
+          logger.error(f"Tool execution error ({tool_name}): {e}")      
+          return {"success": False, "error": str(e)}
+
+  ---
+  STEP 8: handle_geocode_address()
+
+  FILE: chat/tools.py
+  LINE: 121-150
+
+  FUNCTION: handle_geocode_address(tool_input)
+      tool_input = {"address": "123 Main St, San Francisco"}
+
+  Function Code:
+  def handle_geocode_address(tool_input):
+      """Execute geocoding tool"""
+      address = tool_input.get("address", "")  # "123 Main St, San      
+  Francisco"
+
+      if not address:
+          return {"success": False, "error": "Address is required"}     
+
+      logger.info(f"Geocoding address: {address}")
+      #            ↑
+      #            LOGS: "Geocoding address: 123 Main St, San
+  Francisco"
+
+      result = geocoding_service.geocode(address)
+      #        ↑
+      #        CALLS geocoding_service.geocode() NEXT
+
+      return {
+          "success": True,
+          "latitude": result["lat"],
+          "longitude": result["lng"],
+          "formatted_address": result["formatted_address"],
+          "confidence": result["confidence"],
+          "message": f"Address geocoded successfully
+  ({result['confidence']})"
+      }
+
+  ---
+  STEP 9: GeocodingService.geocode()
+
+  FILE: chat/geocoding.py
+  LINE: 28-65
+
+  FUNCTION: GeocodingService.geocode(address)
+      address = "123 Main St, San Francisco"
+
+  Function Code:
+  def geocode(self, address):
+      """Geocode an address to coordinates"""
+      if not address:
+          return self._error_response("Address is required")
+
+      # Use mock or real API
+      if self.use_mock:  # True (no HERE_API_KEY configured)
+          return self._geocode_mock(address)
+          #      ↑
+          #      CALLS THIS NEXT
+      else:
+          return self._geocode_here(address)
+
+  ---
+  STEP 10: _geocode_mock() - Returns Coordinates
+
+  FILE: chat/geocoding.py
+  LINE: 52-70
+
+  FUNCTION: _geocode_mock(address)
+      address = "123 Main St, San Francisco"
+
+  Function Code:
+  def _geocode_mock(self, address):
+      """Mock geocoding using city detection"""
+      address_lower = address.lower()
+
+      # Try to detect city in address
+      for city_name, (lat, lng) in CITY_COORDINATES.items():
+          if city_name in address_lower:
+              logger.info(f"Mock geocoding detected city:
+  {city_name}")
+              #            ↑
+              #            LOGS: "Mock geocoding detected city: san     
+  francisco"
+
+              return {
+                  "lat": lat,      # 37.7749
+                  "lng": lng,      # -122.4194
+                  "formatted_address": address,
+                  "confidence": "mock"
+              }
+
+      # Default to San Francisco if no city detected
+      return {
+          "lat": 37.7749,
+          "lng": -122.4194,
+          "formatted_address": address,
+          "confidence": "mock"
+      }
+
+  RETURNS:
+  {
+      "lat": 37.7749,
+      "lng": -122.4194,
+      "formatted_address": "123 Main St, San Francisco",
+      "confidence": "mock"
+  }
+
+  ---
+  STEP 11: Back to handle_geocode_address()
+
+  FILE: chat/tools.py
+  LINE: 141-150
+
+  result = {
+      "lat": 37.7749,
+      "lng": -122.4194,
+      "formatted_address": "123 Main St, San Francisco",
+      "confidence": "mock"
+  }
+
+  RETURNS:
+  {
+      "success": True,
+      "latitude": 37.7749,
+      "longitude": -122.4194,
+      "formatted_address": "123 Main St, San Francisco",
+      "confidence": "mock",
+      "message": "Address geocoded successfully (mock)"
+  }
+
+  ---
+  STEP 12: Back to _process_response() - Tool Result Received
+
+  FILE: chat/providers/gemini_provider.py
+  LINE: 285-310
+
+  tool_result = {
+      "success": True,
+      "latitude": 37.7749,
+      "longitude": -122.4194,
+      "formatted_address": "123 Main St, San Francisco",
+      "confidence": "mock",
+      "message": "Address geocoded successfully (mock)"
+  }
+
+  # Track for transparency
+  tool_calls_made.append({
+      "tool": "geocode_address",
+      "input": {"address": "123 Main St, San Francisco"},
+      "result": tool_result
+  })
+
+  conversation.add_tool_result("geocode_address", function_args,        
+  tool_result)
+
+  # Send function result back to Gemini
+  current_response = chat.send_message(
+      genai.protos.Content(
+          parts=[genai.protos.Part(
+              function_response=genai.protos.FunctionResponse(
+                  name="geocode_address",
+                  response={"result": tool_result}
+              )
+          )]
+      )
+  )
+  #  ↑
+  #  🌐 API CALL TO GEMINI WITH GEOCODING RESULT
+
+  ---
+  STEP 13: Gemini Receives Geocoding Result
+
+  🌐 GOOGLE GEMINI API (External)
+
+  RECEIVES:
+  - Function: geocode_address
+  - Result: {
+      "success": True,
+      "latitude": 37.7749,
+      "longitude": -122.4194
+    }
+
+  AI ANALYZES:
+  "Great! I now have GPS coordinates:
+   ✅ Customer Name: John Doe
+   ✅ Address: 123 Main St, San Francisco
+   ✅ Latitude: 37.7749
+   ✅ Longitude: -122.4194
+
+   DECISION: Now I can create the order in the database!
+             Call create_order tool."
+
+  RETURNS TO CODE:
+  response = {
+      candidates: [{
+          content: {
+              parts: [{
+                  function_call: {
+                      name: "create_order",
+                      args: {
+                          "customer_name": "John Doe",
+                          "delivery_address": "123 Main St, San
+  Francisco",
+                          "delivery_lat": 37.7749,
+                          "delivery_lng": -122.4194,
+                          "priority": "standard"
+                      }
+                  }
+              }]
+          }
+      }]
+  }
+
+  ---
+  STEP 14: Loop Continues - Detects create_order
+
+  FILE: chat/providers/gemini_provider.py
+  LINE: 252-285
+
+  # Still in the for loop (iteration 2)
+  first_part = current_response.candidates[0].content.parts[0]
+  has_fc = True  # Another function call detected
+
+  function_call = first_part.function_call
+  function_name = function_call.name  # "create_order"
+  function_args = dict(function_call.args)  # {customer_name,
+  address, lat, lng...}
+
+  logger.info(f"Gemini executing function: {function_name}
+  (iteration 2)")
+  #            ↑
+  #            LOGS: "Gemini executing function: create_order
+  (iteration 2)"
+
+  # Execute the tool
+  tool_result = execute_tool(function_name, function_args)
+  #             ↑
+  #             CALLS execute_tool() AGAIN
+
+  ---
+  STEP 15: execute_tool() - Routes to create_order
+
+  FILE: chat/tools.py
+  LINE: 92-118
+
+  FUNCTION: execute_tool(tool_name, tool_input)
+      tool_name = "create_order"
+      tool_input = {
+          "customer_name": "John Doe",
+          "delivery_address": "123 Main St, San Francisco",
+          "delivery_lat": 37.7749,
+          "delivery_lng": -122.4194,
+          "priority": "standard"
+      }
+
+  Function Code:
+  def execute_tool(tool_name, tool_input):
+      try:
+          if tool_name == "geocode_address":
+              return handle_geocode_address(tool_input)
+          elif tool_name == "create_order":
+              return handle_create_order(tool_input)
+              #      ↑
+              #      CALLS THIS NEXT
+
+  ---
+  STEP 16: handle_create_order()
+
+  FILE: chat/tools.py
+  LINE: 153-242
+
+  FUNCTION: handle_create_order(tool_input)
+      tool_input = {
+          "customer_name": "John Doe",
+          "delivery_address": "123 Main St, San Francisco",
+          "delivery_lat": 37.7749,
+          "delivery_lng": -122.4194,
+          "priority": "standard"
+      }
+
+  Function Code:
+  def handle_create_order(tool_input):
+      """Execute order creation tool"""
+
+      # Extract fields with defaults
+      customer_name = tool_input.get("customer_name")  # "John Doe"     
+      customer_phone = tool_input.get("customer_phone")  # None
+      customer_email = tool_input.get("customer_email")  # None
+      delivery_address = tool_input.get("delivery_address")  # "123     
+  Main St, San Francisco"
+      delivery_lat = tool_input.get("delivery_lat")  # 37.7749
+      delivery_lng = tool_input.get("delivery_lng")  # -122.4194        
+      priority = tool_input.get("priority", "standard")  #
+  "standard"
+      special_instructions = tool_input.get("special_instructions")     
+   # None
+      weight_kg = tool_input.get("weight_kg", 5.0)  # 5.0
+
+      # Validate required fields
+      if not all([customer_name, delivery_address, delivery_lat,        
+  delivery_lng]):
+          return {"success": False, "error": "Missing required
+  fields..."}
+
+      # Generate order ID
+      now = datetime.now()
+      order_id = f"ORD-{now.strftime('%Y%m%d%H%M%S')}"
+      #          ↑
+      #          e.g., "ORD-20251114015858"
+
+      # Handle time window
+      time_window_end = now + timedelta(hours=6)  # 6 hours from now    
+      time_window_start = now + timedelta(hours=2)  # 2 hours from      
+  now
+
+      # Insert into database
+      query = """
+          INSERT INTO orders (
+              order_id, customer_name, customer_phone,
+  customer_email,
+              delivery_address, delivery_lat, delivery_lng,
+              time_window_start, time_window_end,
+              priority, weight_kg, status, special_instructions
+          ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s,     
+  %s)
+      """
+
+      params = (
+          order_id,                # "ORD-20251114015858"
+          customer_name,           # "John Doe"
+          customer_phone,          # None
+          customer_email,          # None
+          delivery_address,        # "123 Main St, San Francisco"       
+          delivery_lat,            # 37.7749
+          delivery_lng,            # -122.4194
+          time_window_start,       # 2025-11-14 03:58:58
+          time_window_end,         # 2025-11-14 07:58:58
+          priority,                # "standard"
+          weight_kg,               # 5.0
+          "pending",               # status
+          special_instructions     # None
+      )
+
+      try:
+          execute_write(query, params)
+          #     ↑
+          #     CALLS THIS NEXT - DATABASE WRITE!
+
+  ---
+  STEP 17: execute_write() - INSERT INTO DATABASE
+
+  FILE: database/connection.py
+  LINE: 71-97
+
+  FUNCTION: execute_write(query, params)
+      query = "INSERT INTO orders (...) VALUES (%s, %s, ...)"
+      params = ("ORD-20251114015858", "John Doe", None, None, "123      
+  Main St...", ...)
+
+  Function Code:
+  def execute_write(query, params=None):
+      """Execute a write query (INSERT, UPDATE, DELETE)"""
+      try:
+          # Connect to PostgreSQL
+          conn = get_db_connection()
+          #      ↑
+          #      Opens connection to localhost:5432/fleetmind
+
+          logger.info("Database connection established:
+  fleetmind@localhost")
+
+          cursor = conn.cursor()
+
+          # Execute INSERT query
+          cursor.execute(query, params)
+          #     ↑
+          #     💾 EXECUTES SQL:
+          #     INSERT INTO orders (order_id, customer_name, ...)       
+          #     VALUES ('ORD-20251114015858', 'John Doe', ...)
+
+          conn.commit()  # ← SAVES TO POSTGRESQL PERMANENTLY!
+
+          rows_affected = cursor.rowcount  # 1
+
+          cursor.close()
+          conn.close()
+
+          logger.info("Database connection closed")
+
+          return rows_affected  # Returns 1
+
+  DATABASE STATE:
+  -- New row added to orders table:
+  ORDER_ID: ORD-20251114015858
+  CUSTOMER_NAME: John Doe
+  CUSTOMER_PHONE: NULL
+  CUSTOMER_EMAIL: NULL
+  DELIVERY_ADDRESS: 123 Main St, San Francisco
+  DELIVERY_LAT: 37.7749
+  DELIVERY_LNG: -122.4194
+  STATUS: pending
+  PRIORITY: standard
+  WEIGHT_KG: 5.0
+  CREATED_AT: 2025-11-14 01:58:58
+
+  ---
+  STEP 18: Back to handle_create_order() - Success!
+
+  FILE: chat/tools.py
+  LINE: 224-242
+
+  execute_write(query, params)  # Returned 1 (success)
+
+  logger.info(f"Order created: {order_id}")
+  #            ↑
+  #            LOGS: "Order created: ORD-20251114015858"
+
+  return {
+      "success": True,
+      "order_id": "ORD-20251114015858",
+      "status": "pending",
+      "customer": "John Doe",
+      "address": "123 Main St, San Francisco",
+      "deadline": "2025-11-14 07:58",
+      "priority": "standard",
+      "message": "Order ORD-20251114015858 created successfully!"       
+  }
+
+  ---
+  STEP 19: Back to _process_response() - Second Tool Complete
+
+  FILE: chat/providers/gemini_provider.py
+  LINE: 285-310
+
+  tool_result = {
+      "success": True,
+      "order_id": "ORD-20251114015858",
+      "status": "pending",
+      "customer": "John Doe",
+      ...
+  }
+
+  # Track for transparency
+  tool_calls_made.append({
+      "tool": "create_order",
+      "input": {
+          "customer_name": "John Doe",
+          "delivery_address": "123 Main St, San Francisco",
+          "delivery_lat": 37.7749,
+          "delivery_lng": -122.4194
+      },
+      "result": tool_result
+  })
+
+  conversation.add_tool_result("create_order", function_args,
+  tool_result)
+
+  # Send function result back to Gemini
+  current_response = chat.send_message(
+      genai.protos.Content(
+          parts=[genai.protos.Part(
+              function_response=genai.protos.FunctionResponse(
+                  name="create_order",
+                  response={"result": tool_result}
+              )
+          )]
+      )
+  )
+  #  ↑
+  #  🌐 API CALL TO GEMINI WITH ORDER CREATION RESULT
+
+  ---
+  STEP 20: Gemini Generates Final Response
+
+  🌐 GOOGLE GEMINI API (External)
+
+  RECEIVES:
+  - Function: create_order
+  - Result: {
+      "success": True,
+      "order_id": "ORD-20251114015858",
+      "customer": "John Doe",
+      "address": "123 Main St, San Francisco"
+    }
+
+  AI ANALYZES:
+  "Perfect! Order successfully created in database!
+   Let me tell the user with a nice summary."
+
+  GENERATES TEXT RESPONSE:
+  "Awesome! I have created the order for John Doe.
+
+  **Here's a summary:**
+  • Order ID: ORD-20251114015858
+  • Customer: John Doe
+  • Address: 123 Main St, San Francisco
+  • Status: Pending
+  • Priority: Standard
+
+  The order has been successfully saved to the database!"
+
+  RETURNS TO CODE:
+  response = {
+      candidates: [{
+          content: {
+              parts: [{
+                  text: "Awesome! I have created the order for John     
+  Doe.\n\n**Here's a summary:**..."
+              }]
+          }
+      }]
+  }
+
+  ---
+  STEP 21: _process_response() - Extract Final Text
+
+  FILE: chat/providers/gemini_provider.py
+  LINE: 272-356
+
+  # Loop detects no more function calls
+  logger.info(f"No more function calls after iteration 2")
+
+  # Extract text from final response
+  parts = current_response.candidates[0].content.parts
+  logger.info(f"Extracting text from {len(parts)} parts")
+
+  for idx, part in enumerate(parts):
+      if hasattr(part, 'text') and part.text:
+          logger.info(f"Part {idx} has text: {part.text[:50]}...")      
+          final_text += part.text
+
+  # final_text = "Awesome! I have created the order for John Doe..."    
+
+  logger.info(f"Returning response: {final_text[:100]}")
+
+  conversation.add_message("assistant", final_text)
+
+  return final_text, tool_calls_made
+  #      ↑           ↑
+  #      Response    List of 2 tool calls [geocode, create_order]       
+
+  RETURNS:
+  (
+      "Awesome! I have created the order for John Doe.\n\n**Here's a    
+   summary:**...",
+      [
+          {"tool": "geocode_address", "input": {...}, "result":
+  {...}},
+          {"tool": "create_order", "input": {...}, "result": {...}}     
+      ]
+  )
+
+  ---
+  STEP 22: Back Through All Functions
+
+  ← Returns to: GeminiProvider.process_message() (line 206)
+  ← Returns to: ChatEngine.process_message() (line 58)
+  ← Returns to: handle_chat_message() (line 223)
+  ← Returns to: send_message() (line 443)
+  ← Returns to: Gradio UI (line 448)
+
+  ---
+  STEP 23: Gradio Updates UI
+
+  FILE: ui/app.py
+  LINE: 448-452
+
+  send_btn.click(
+      fn=send_message,
+      outputs=[chatbot, tool_display, conversation_state, msg_input]    
+      #        ↑        ↑
+      #        Updates  Shows tool calls
+  )
+
+  CHATBOT DISPLAYS:
+  User: "Create an order for John Doe at 123 Main St, San Francisco"    

generate_api_key.py

@@ -1,142 +0,0 @@
-#!/usr/bin/env python3
-"""
-FleetMind API Key Generator
-
-Generate API keys for users to authenticate with FleetMind MCP Server.
-
-Usage:
-    python generate_api_key.py
-    python generate_api_key.py --email user@example.com --name "John Doe"
-    python generate_api_key.py --list
-    python generate_api_key.py --revoke user@example.com
-"""
-
-import argparse
-import sys
-from database.api_keys import generate_api_key, list_api_keys, revoke_api_key
-
-def main():
-    parser = argparse.ArgumentParser(
-        description='FleetMind API Key Management',
-        formatter_class=argparse.RawDescriptionHelpFormatter,
-        epilog="""
-Examples:
-  # Interactive mode (prompts for email and name)
-  python generate_api_key.py
-
-  # Generate key with arguments
-  python generate_api_key.py --email alice@company.com --name "Alice Smith"
-
-  # List all API keys
-  python generate_api_key.py --list
-
-  # Revoke a key
-  python generate_api_key.py --revoke alice@company.com
-        """
-    )
-
-    parser.add_argument('--email', help='User email address')
-    parser.add_argument('--name', help='User display name')
-    parser.add_argument('--list', action='store_true', help='List all API keys')
-    parser.add_argument('--revoke', metavar='EMAIL', help='Revoke API key for email')
-
-    args = parser.parse_args()
-
-    # List API keys
-    if args.list:
-        print("\n" + "="*80)
-        print("FLEETMIND API KEYS")
-        print("="*80 + "\n")
-
-        keys = list_api_keys()
-        if not keys:
-            print("No API keys found.\n")
-            return
-
-        for key in keys:
-            status = "✅ Active" if key['is_active'] else "❌ Revoked"
-            print(f"Email:      {key['email']}")
-            print(f"Name:       {key['name']}")
-            print(f"User ID:    {key['user_id']}")
-            print(f"Key:        {key['key_preview']}")
-            print(f"Created:    {key['created_at']}")
-            print(f"Last Used:  {key['last_used_at'] or 'Never'}")
-            print(f"Status:     {status}")
-            print("-" * 80)
-
-        print()
-        return
-
-    # Revoke API key
-    if args.revoke:
-        print(f"\n⚠️  Revoking API key for {args.revoke}...")
-        result = revoke_api_key(args.revoke)
-
-        if result['success']:
-            print(f"✅ {result['message']}\n")
-        else:
-            print(f"❌ Error: {result['error']}\n")
-            sys.exit(1)
-        return
-
-    # Generate new API key
-    if not args.email:
-        # Interactive mode
-        print("\n" + "="*80)
-        print("GENERATE NEW FLEETMIND API KEY")
-        print("="*80 + "\n")
-
-        email = input("Enter user email: ").strip()
-        if not email:
-            print("❌ Email is required")
-            sys.exit(1)
-
-        name = input("Enter user name (optional): ").strip() or None
-    else:
-        email = args.email
-        name = args.name
-
-    print(f"\nGenerating API key for {email}...")
-    result = generate_api_key(email, name)
-
-    if not result['success']:
-        print(f"\n❌ Error: {result['error']}\n")
-        sys.exit(1)
-
-    # Success! Display the API key
-    print("\n" + "="*80)
-    print("✅ API KEY GENERATED SUCCESSFULLY")
-    print("="*80 + "\n")
-
-    print(f"Email:      {result['email']}")
-    print(f"Name:       {result['name']}")
-    print(f"User ID:    {result['user_id']}")
-    print(f"Created:    {result['created_at']}")
-    print()
-    print("🔑 API KEY (copy this now - it won't be shown again!):")
-    print("-" * 80)
-    print(result['api_key'])
-    print("-" * 80)
-    print()
-    print("📋 Add this to your Claude Desktop config:")
-    print()
-    print('  {')
-    print('    "mcpServers": {')
-    print('      "fleetmind": {')
-    print('        "command": "npx",')
-    print('        "args": [')
-    print('          "mcp-remote",')
-    print('          "https://mcp-1st-birthday-fleetmind-dispatch-ai.hf.space/sse"')
-    print('        ],')
-    print('        "env": {')
-    print(f'          "FLEETMIND_API_KEY": "{result["api_key"]}"')
-    print('        }')
-    print('      }')
-    print('    }')
-    print('  }')
-    print()
-    print("⚠️  IMPORTANT: Save this API key securely. You won't be able to see it again!")
-    print()
-
-if __name__ == "__main__":
-    main()

mcp_config.json

@@ -1,30 +0,0 @@
-{
-  "name": "fleetmind",
-  "version": "1.0.0",
-  "description": "FleetMind Dispatch Coordinator - AI-powered delivery dispatch management system",
-  "author": "FleetMind Team",
-  "license": "MIT",
-  "server": {
-    "command": "python",
-    "args": ["server.py"],
-    "env": {
-      "GOOGLE_MAPS_API_KEY": "${GOOGLE_MAPS_API_KEY}",
-      "DB_HOST": "${DB_HOST}",
-      "DB_PORT": "${DB_PORT}",
-      "DB_NAME": "${DB_NAME}",
-      "DB_USER": "${DB_USER}",
-      "DB_PASSWORD": "${DB_PASSWORD}"
-    }
-  },
-  "capabilities": {
-    "tools": 18,
-    "resources": 2,
-    "prompts": 3
-  },
-  "categories": [
-    "logistics",
-    "dispatch",
-    "delivery",
-    "fleet-management"
-  ]
-}

proxy.py

@@ -1,244 +0,0 @@
-"""
-FleetMind MCP Authentication Proxy
-Captures API keys from initial SSE connections and injects them into tool requests.
-
-This proxy sits between MCP clients and the FastMCP server, solving the
-multi-tenant authentication problem by:
-1. Capturing api_key from initial /sse?api_key=xxx connection
-2. Storing api_key mapped to session_id
-3. Injecting api_key into subsequent /messages/?session_id=xxx requests
-
-Architecture:
-  MCP Client -> Proxy (port 7860) -> FastMCP (port 7861)
-"""
-
-import asyncio
-import logging
-import os
-from aiohttp import web, ClientSession, ClientTimeout
-from aiohttp.client_exceptions import ClientConnectionResetError
-from urllib.parse import urlencode, parse_qs, urlparse, urlunparse
-import sys
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[logging.StreamHandler()]
-)
-logger = logging.getLogger(__name__)
-
-# Proxy configuration
-# On HuggingFace, PORT env var is set to 7860
-PROXY_PORT = int(os.getenv("PORT", 7860))  # Public-facing port
-FASTMCP_PORT = 7861  # Internal FastMCP server port (fixed)
-FASTMCP_HOST = "localhost"
-
-# Session storage: session_id -> api_key
-session_api_keys = {}
-
-
-async def proxy_handler(request):
-    """
-    Main proxy handler - forwards all requests to FastMCP server.
-    Captures API keys from SSE connections and injects them into tool calls.
-    """
-    path = request.path
-    query_params = dict(request.query)
-
-    # Extract API key if present (initial SSE connection)
-    api_key = query_params.get('api_key')
-    session_id = query_params.get('session_id')
-
-    # STEP 1: Capture API key from initial SSE connection
-    if api_key and path == '/sse':
-        logger.info(f"[AUTH] Captured API key from SSE connection: {api_key[:20]}...")
-        # Store temporarily - will be linked to session when we see it
-        session_api_keys['_pending_api_key'] = api_key
-
-    # STEP 2: Link session_id to API key (from /messages requests)
-    if session_id and path.startswith('/messages'):
-        # Check if we have a stored API key for this session
-        if session_id not in session_api_keys:
-            # Link this session to the pending API key
-            if '_pending_api_key' in session_api_keys:
-                api_key_to_store = session_api_keys['_pending_api_key']
-                session_api_keys[session_id] = api_key_to_store
-                logger.info(f"[AUTH] Linked session {session_id[:12]}... to API key")
-
-        # STEP 3: Inject API key into request for FastMCP
-        stored_api_key = session_api_keys.get(session_id)
-        if stored_api_key:
-            query_params['api_key'] = stored_api_key
-            logger.debug(f"[AUTH] Injected API key into request for session {session_id[:12]}...")
-
-    # Build target URL for FastMCP server
-    query_string = urlencode(query_params) if query_params else ""
-    target_url = f"http://{FASTMCP_HOST}:{FASTMCP_PORT}{path}"
-    if query_string:
-        target_url += f"?{query_string}"
-
-    # Forward request to FastMCP
-    # For SSE connections: total=None disables overall timeout (keeps connection alive)
-    # Still use socket timeouts for safety (sock_connect, sock_read)
-    async with ClientSession(
-        timeout=ClientTimeout(
-            total=None,         # No total timeout for long-lived SSE connections
-            sock_connect=30,    # 30 seconds for initial connection
-            sock_read=300       # 5 minutes for individual socket reads
-        )
-    ) as session:
-        try:
-            # Copy headers
-            headers = dict(request.headers)
-            # Remove host header to avoid conflicts
-            headers.pop('Host', None)
-
-            # Forward request based on method
-            if request.method == 'GET':
-                async with session.get(target_url, headers=headers) as resp:
-                    # For SSE, stream the response
-                    if 'text/event-stream' in resp.content_type:
-                        # Create streaming response for SSE
-                        response = web.StreamResponse(
-                            status=resp.status,
-                            reason=resp.reason,
-                            headers=dict(resp.headers)
-                        )
-                        await response.prepare(request)
-
-                        # Background task to send keep-alive pings (prevents timeout)
-                        async def send_keepalive():
-                            try:
-                                while True:
-                                    await asyncio.sleep(30)  # Send ping every 30 seconds
-                                    await response.write(b":\n\n")  # SSE comment (ignored by client)
-                            except asyncio.CancelledError:
-                                pass
-
-                        keepalive_task = asyncio.create_task(send_keepalive())
-
-                        try:
-                            # Stream chunks from FastMCP to client
-                            async for chunk in resp.content.iter_any():
-                                await response.write(chunk)
-
-                            await response.write_eof()
-                        finally:
-                            # Cancel keep-alive task when streaming completes
-                            keepalive_task.cancel()
-                            try:
-                                await keepalive_task
-                            except asyncio.CancelledError:
-                                pass
-
-                        return response
-                    else:
-                        # For regular responses, read entire body
-                        body = await resp.read()
-                        resp_headers = dict(resp.headers)
-                        return web.Response(
-                            body=body,
-                            status=resp.status,
-                            headers=resp_headers
-                        )
-
-            elif request.method == 'POST':
-                body = await request.read()
-                async with session.post(target_url, data=body, headers=headers) as resp:
-                    resp_body = await resp.read()
-                    # Don't pass content_type separately - it's already in headers
-                    resp_headers = dict(resp.headers)
-                    return web.Response(
-                        body=resp_body,
-                        status=resp.status,
-                        headers=resp_headers
-                    )
-
-            else:
-                # Forward other methods
-                async with session.request(
-                    request.method,
-                    target_url,
-                    data=await request.read(),
-                    headers=headers
-                ) as resp:
-                    body = await resp.read()
-                    return web.Response(
-                        body=body,
-                        status=resp.status,
-                        headers=dict(resp.headers)
-                    )
-
-        except (ClientConnectionResetError, ConnectionResetError) as e:
-            # Client disconnected - this is normal for SSE connections
-            # Log at DEBUG level to reduce noise
-            logger.debug(f"[SSE] Client disconnected: {e}")
-            return web.Response(text="Client disconnected", status=499)
-
-        except Exception as e:
-            import traceback
-            error_details = traceback.format_exc()
-            logger.error(f"[ERROR] Proxy error: {type(e).__name__}: {e}")
-            logger.error(f"[ERROR] Traceback:\n{error_details}")
-            return web.Response(
-                text=f"Proxy error: {type(e).__name__}: {str(e)}",
-                status=502
-            )
-
-
-async def health_check(request):
-    """Health check endpoint"""
-    return web.Response(text="FleetMind Proxy OK", status=200)
-
-
-def create_app():
-    """Create and configure the proxy application"""
-    app = web.Application()
-
-    # Health check endpoint
-    app.router.add_get('/health', health_check)
-
-    # Proxy all other requests
-    app.router.add_route('*', '/{path:.*}', proxy_handler)
-
-    return app
-
-
-async def main():
-    """Start the proxy server"""
-    print("\n" + "=" * 70)
-    print("FleetMind MCP Authentication Proxy")
-    print("=" * 70)
-    print(f"Proxy listening on: http://0.0.0.0:{PROXY_PORT}")
-    print(f"Forwarding to FastMCP: http://{FASTMCP_HOST}:{FASTMCP_PORT}")
-    print("=" * 70)
-    print("[OK] Multi-tenant authentication enabled")
-    print("[OK] API keys captured from SSE connections")
-    print("[OK] Sessions automatically linked to API keys")
-    print("=" * 70 + "\n")
-
-    app = create_app()
-    runner = web.AppRunner(app)
-    await runner.setup()
-
-    site = web.TCPSite(runner, '0.0.0.0', PROXY_PORT)
-    await site.start()
-
-    logger.info(f"[OK] Proxy server started on port {PROXY_PORT}")
-    logger.info(f"[OK] Forwarding to FastMCP on {FASTMCP_HOST}:{FASTMCP_PORT}")
-
-    # Keep running
-    try:
-        await asyncio.Event().wait()
-    except KeyboardInterrupt:
-        logger.info("Shutting down proxy server...")
-        await runner.cleanup()
-
-
-if __name__ == "__main__":
-    try:
-        asyncio.run(main())
-    except KeyboardInterrupt:
-        print("\nProxy server stopped.")
-        sys.exit(0)

pyproject.toml

@@ -1,69 +0,0 @@
-[project]
-name = "fleetmind-mcp"
-version = "1.0.0"
-description = "FleetMind Dispatch Coordinator MCP Server - AI-powered delivery management"
-readme = "README.md"
-requires-python = ">=3.10"
-license = {text = "MIT"}
-authors = [
-    {name = "FleetMind Team"}
-]
-keywords = ["mcp", "dispatch", "delivery", "logistics", "ai", "anthropic"]
-classifiers = [
-    "Development Status :: 4 - Beta",
-    "Intended Audience :: Developers",
-    "License :: OSI Approved :: MIT License",
-    "Programming Language :: Python :: 3",
-    "Programming Language :: Python :: 3.10",
-    "Programming Language :: Python :: 3.11",
-    "Programming Language :: Python :: 3.12",
-]
-
-dependencies = [
-    "fastmcp>=0.3.0",
-    "psycopg2-binary>=2.9.9",
-    "googlemaps>=4.10.0",
-    "python-dotenv>=1.0.0",
-    "pydantic>=2.8.2"
-]
-
-[project.optional-dependencies]
-dev = [
-    "pytest>=8.0.0",
-    "pytest-asyncio>=0.23.0",
-    "mypy>=1.8.0",
-    "black>=24.0.0",
-    "ruff>=0.1.0"
-]
-
-[project.scripts]
-fleetmind-mcp = "server:main"
-
-[project.urls]
-Homepage = "https://github.com/your-org/fleetmind-mcp"
-Repository = "https://github.com/your-org/fleetmind-mcp"
-Issues = "https://github.com/your-org/fleetmind-mcp/issues"
-
-[build-system]
-requires = ["setuptools>=65.0", "wheel"]
-build-backend = "setuptools.build_meta"
-
-[tool.pytest.ini_options]
-testpaths = ["tests"]
-python_files = "test_*.py"
-python_functions = "test_*"
-addopts = "-v --strict-markers"
-
-[tool.mypy]
-python_version = "3.10"
-warn_return_any = true
-warn_unused_configs = true
-disallow_untyped_defs = false
-
-[tool.black]
-line-length = 100
-target-version = ['py310', 'py311', 'py312']
-
-[tool.ruff]
-line-length = 100
-target-version = "py310"

requirements.txt

@@ -1,33 +1,27 @@
-# ============================================================================
-# FleetMind MCP Server - HuggingFace Space (Track 1)
-# MCP-1st-Birthday Hackathon - Building MCP Servers
-# ============================================================================
-
-# Core MCP Framework
+# Core Framework
+gradio>=5.9.0
 fastmcp>=0.3.0
-pydantic>=2.8.2
-
-# Web Framework (for landing page)
-fastapi>=0.104.0
-uvicorn>=0.24.0
 
-# Authentication Proxy
-aiohttp>=3.9.0
+# AI/ML
+anthropic>=0.40.0
+google-generativeai>=0.3.0
 
-# Database
+# Data & Database
+pandas>=2.2.0
+faker>=23.0.0
 psycopg2-binary>=2.9.9
 
 # API Clients
-googlemaps>=4.10.0
-google-generativeai>=0.8.0
 requests>=2.31.0
+httpx>=0.27.1
 
 # Utilities
 python-dotenv>=1.0.0
+pydantic>=2.5.3
+
+# Testing
+pytest>=8.0.0
+pytest-asyncio>=0.23.0
 
-# Development & Testing (optional - not needed for HF Space deployment)
-# pytest>=8.0.0
-# pytest-asyncio>=0.23.0
-# mypy>=1.8.0
-# black>=24.0.0
-# ruff>=0.1.0
+# Type Checking
+mypy>=1.8.0

scripts/test_db.py

@@ -0,0 +1,169 @@
+"""
+Test script to verify PostgreSQL database operations
+"""
+
+import sys
+from pathlib import Path
+from datetime import datetime, timedelta
+
+# Add parent directory to path
+sys.path.insert(0, str(Path(__file__).parent.parent))
+
+from database.connection import execute_query, execute_write
+import logging
+
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+
+def test_insert_order():
+    """Test inserting a new order"""
+    logger.info("Testing order insertion...")
+
+    now = datetime.now()
+    time_window_start = now + timedelta(hours=2)
+    time_window_end = now + timedelta(hours=6)
+
+    query = """
+        INSERT INTO orders (
+            order_id, customer_name, customer_phone, customer_email,
+            delivery_address, delivery_lat, delivery_lng,
+            time_window_start, time_window_end,
+            priority, weight_kg, status
+        ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
+    """
+
+    params = (
+        "ORD-TEST-001",
+        "John Doe",
+        "+1-555-0123",
+        "john.doe@example.com",
+        "123 Main Street, San Francisco, CA 94103",
+        37.7749,
+        -122.4194,
+        time_window_start,
+        time_window_end,
+        "standard",
+        5.5,
+        "pending"
+    )
+
+    try:
+        result = execute_write(query, params)
+        logger.info(f"✓ Order inserted successfully (rows affected: {result})")
+        return True
+    except Exception as e:
+        logger.error(f"✗ Failed to insert order: {e}")
+        return False
+
+
+def test_query_orders():
+    """Test querying orders"""
+    logger.info("Testing order query...")
+
+    query = "SELECT * FROM orders WHERE status = %s"
+    params = ("pending",)
+
+    try:
+        results = execute_query(query, params)
+        logger.info(f"✓ Query successful: Found {len(results)} pending orders")
+
+        for row in results:
+            logger.info(f"  Order ID: {row['order_id']}")
+            logger.info(f"  Customer: {row['customer_name']}")
+            logger.info(f"  Address: {row['delivery_address']}")
+            logger.info(f"  Priority: {row['priority']}")
+            logger.info(f"  Status: {row['status']}")
+            logger.info("  ---")
+
+        return True
+    except Exception as e:
+        logger.error(f"✗ Failed to query orders: {e}")
+        return False
+
+
+def test_update_order():
+    """Test updating an order"""
+    logger.info("Testing order update...")
+
+    query = "UPDATE orders SET status = %s, assigned_driver_id = %s WHERE order_id = %s"
+    params = ("assigned", "DRV-001", "ORD-TEST-001")
+
+    try:
+        result = execute_write(query, params)
+        logger.info(f"✓ Order updated successfully (rows affected: {result})")
+
+        # Verify update
+        verify_query = "SELECT status, assigned_driver_id FROM orders WHERE order_id = %s"
+        verify_result = execute_query(verify_query, ("ORD-TEST-001",))
+
+        if verify_result:
+            row = verify_result[0]
+            logger.info(f"  New status: {row['status']}")
+            logger.info(f"  Assigned driver: {row['assigned_driver_id']}")
+
+        return True
+    except Exception as e:
+        logger.error(f"✗ Failed to update order: {e}")
+        return False
+
+
+def test_delete_order():
+    """Test deleting the test order"""
+    logger.info("Testing order deletion (cleanup)...")
+
+    query = "DELETE FROM orders WHERE order_id = %s"
+    params = ("ORD-TEST-001",)
+
+    try:
+        result = execute_write(query, params)
+        logger.info(f"✓ Order deleted successfully (rows affected: {result})")
+        return True
+    except Exception as e:
+        logger.error(f"✗ Failed to delete order: {e}")
+        return False
+
+
+def main():
+    """Run all database tests"""
+    logger.info("=" * 50)
+    logger.info("Starting FleetMind PostgreSQL Database Tests")
+    logger.info("=" * 50)
+
+    tests = [
+        ("Insert Order", test_insert_order),
+        ("Query Orders", test_query_orders),
+        ("Update Order", test_update_order),
+        ("Delete Order", test_delete_order),
+    ]
+
+    results = []
+    for test_name, test_func in tests:
+        logger.info(f"\n--- {test_name} ---")
+        success = test_func()
+        results.append((test_name, success))
+
+    # Summary
+    logger.info("\n" + "=" * 50)
+    logger.info("Test Summary")
+    logger.info("=" * 50)
+
+    passed = sum(1 for _, success in results if success)
+    total = len(results)
+
+    for test_name, success in results:
+        status = "✓ PASSED" if success else "✗ FAILED"
+        logger.info(f"{test_name}: {status}")
+
+    logger.info(f"\nTotal: {passed}/{total} tests passed")
+
+    if passed == total:
+        logger.info("\n🎉 All tests passed! Your PostgreSQL database is working correctly!")
+        return 0
+    else:
+        logger.error("\n❌ Some tests failed. Please check the errors above.")
+        return 1
+
+
+if __name__ == "__main__":
+    sys.exit(main())

server.py

@@ -1,2033 +0,0 @@
-"""
-FleetMind Dispatch Coordinator - MCP Server
-Industry-standard Model Context Protocol server for delivery dispatch management
-
-Provides 18 AI tools for order and driver management via standardized MCP protocol.
-Compatible with Claude Desktop, Continue, Cline, and all MCP clients.
-"""
-
-import os
-import sys
-import json
-import logging
-from pathlib import Path
-from typing import Literal
-from datetime import datetime
-from contextvars import ContextVar
-
-# Add project root to path
-sys.path.insert(0, str(Path(__file__).parent))
-
-# Ensure logs directory exists
-logs_dir = Path(__file__).parent / 'logs'
-logs_dir.mkdir(exist_ok=True)
-
-from fastmcp import FastMCP
-
-# Import existing services (unchanged)
-from chat.geocoding import GeocodingService
-from database.connection import execute_query, execute_write, test_connection
-
-# Import permission checking
-from database.user_context import check_permission, get_required_scope
-
-# Configure logging
-logging.basicConfig(
-    level=logging.INFO,
-    format='%(asctime)s - %(name)s - %(levelname)s - %(message)s',
-    handlers=[
-        logging.FileHandler(logs_dir / 'fleetmind_mcp.log'),
-        logging.StreamHandler()
-    ]
-)
-logger = logging.getLogger(__name__)
-
-# ============================================================================
-# API KEY EXTRACTION FROM REQUEST
-# ============================================================================
-
-# Store API key per request using context variable
-_current_api_key: ContextVar[str] = ContextVar('api_key', default=None)
-
-# Session-to-API-key store: maps session_id -> api_key
-# This allows tool calls to authenticate using the API key from the SSE connection
-_session_auth_store: dict[str, str] = {}
-
-def store_session_api_key(session_id: str, api_key: str):
-    """Store API key for a session (called when SSE connection is made)"""
-    _session_auth_store[session_id] = api_key
-    logger.debug(f"Stored API key for session {session_id[:16]}...")
-
-def get_api_key_from_session(session_id: str) -> str:
-    """Get API key from session store"""
-    return _session_auth_store.get(session_id)
-
-def cleanup_session(session_id: str):
-    """Remove session from store when disconnected"""
-    if session_id in _session_auth_store:
-        del _session_auth_store[session_id]
-        logger.debug(f"Cleaned up session {session_id[:16]}...")
-
-def get_api_key_from_context() -> str:
-    """
-    Get API key from the current request context.
-    This is set by our custom dependencies.
-    """
-    return _current_api_key.get(None)
-
-def extract_api_key_from_request():
-    """
-    Extract API key from HTTP request and store in context variable.
-    Called at the start of each tool execution.
-
-    Checks multiple sources:
-    1. api_key query parameter in current request
-    2. session_id query parameter -> lookup in session store
-    """
-    try:
-        from fastmcp.server.dependencies import get_http_request
-        request = get_http_request()
-
-        # METHOD 1: Direct api_key in query params
-        api_key = request.query_params.get('api_key')
-        if api_key:
-            _current_api_key.set(api_key)
-            logger.debug(f"API key extracted from request: {api_key[:10]}...")
-            return api_key
-
-        # METHOD 2: Look up by session_id (for MCP tool calls)
-        session_id = request.query_params.get('session_id')
-        if session_id:
-            api_key = get_api_key_from_session(session_id)
-            if api_key:
-                _current_api_key.set(api_key)
-                logger.debug(f"API key found via session {session_id[:16]}...")
-                return api_key
-            else:
-                logger.debug(f"No API key found for session {session_id[:16]}...")
-
-    except RuntimeError:
-        # No HTTP request available (e.g., stdio transport)
-        logger.debug("No HTTP request available for API key extraction")
-    return None
-
-# ============================================================================
-# MCP SERVER INITIALIZATION
-# ============================================================================
-mcp = FastMCP(
-    name="FleetMind Dispatch Coordinator",
-    version="1.0.0"
-    # Note: request_timeout not supported in FastMCP 2.13.1
-    # Timeout handling is done in proxy.py instead
-)
-
-# ============================================================================
-# FASTMCP AUTHENTICATION MIDDLEWARE
-# Uses FastMCP's native middleware system to properly pass user context to tools
-# Reference: https://gelembjuk.com/blog/post/authentication-remote-mcp-server-python/
-# ============================================================================
-try:
-    from fastmcp.server.middleware import Middleware, MiddlewareContext
-    from fastmcp.exceptions import ToolError
-
-    class ApiKeyAuthMiddleware(Middleware):
-        """
-        FastMCP middleware for API key authentication.
-        Validates API key from request query params and injects user info into context.
-        """
-
-        async def on_call_tool(self, context: MiddlewareContext, call_next):
-            """Intercept tool calls to validate authentication"""
-            try:
-                from fastmcp.server.dependencies import get_http_request
-                request = get_http_request()
-
-                # Get API key from query params
-                api_key = request.query_params.get('api_key')
-
-                # Also check session store if no direct api_key
-                if not api_key:
-                    session_id = request.query_params.get('session_id')
-                    if session_id:
-                        api_key = get_api_key_from_session(session_id)
-
-                if api_key:
-                    # Validate API key and get user info
-                    from database.api_keys import verify_api_key
-                    user_info = verify_api_key(api_key)
-
-                    if user_info:
-                        # Store user info in context for tools to access
-                        context.fastmcp_context.set_state("user_id", user_info['user_id'])
-                        context.fastmcp_context.set_state("user_email", user_info['email'])
-                        context.fastmcp_context.set_state("user_scopes", user_info.get('scopes', []))
-                        context.fastmcp_context.set_state("user_name", user_info.get('name', ''))
-                        logger.info(f"✅ Auth middleware: User {user_info['email']} authenticated")
-                        return await call_next(context)
-                    else:
-                        logger.warning(f"❌ Auth middleware: Invalid API key {api_key[:10]}...")
-
-                # Check SKIP_AUTH for development
-                env = os.getenv("ENV") or os.getenv("ENVIRONMENT", "production")
-                skip_auth = os.getenv("SKIP_AUTH", "false").lower() == "true"
-
-                if skip_auth and env.lower() != "production":
-                    # Development mode - use dev user
-                    context.fastmcp_context.set_state("user_id", "dev-user")
-                    context.fastmcp_context.set_state("user_email", "dev@fleetmind.local")
-                    context.fastmcp_context.set_state("user_scopes", ["admin"])
-                    context.fastmcp_context.set_state("user_name", "Development User")
-                    logger.warning(f"⚠️ Auth middleware: SKIP_AUTH enabled, using dev user")
-                    return await call_next(context)
-
-                # No valid authentication
-                raise ToolError("Authentication required. Please provide a valid API key.")
-
-            except ImportError:
-                # get_http_request not available (stdio transport)
-                logger.debug("Auth middleware: No HTTP request available")
-                return await call_next(context)
-
-    # Register the middleware with FastMCP
-    mcp.add_middleware(ApiKeyAuthMiddleware())
-    logger.info("[Auth] FastMCP ApiKeyAuthMiddleware registered")
-
-except ImportError as e:
-    logger.warning(f"[Auth] Could not import FastMCP middleware: {e}")
-    logger.warning("[Auth] Falling back to per-tool authentication")
-
-# Initialize shared services
-logger.info("Initializing FleetMind MCP Server...")
-geocoding_service = GeocodingService()
-logger.info(f"Geocoding Service: {geocoding_service.get_status()}")
-
-# Test database connection
-try:
-    test_connection()
-    logger.info("Database: Connected to PostgreSQL")
-except Exception as e:
-    logger.error(f"Database: Connection failed - {e}")
-
-# ============================================================================
-# AUTHENTICATION - API KEY SYSTEM
-# ============================================================================
-
-def get_authenticated_user(ctx=None):
-    """
-    Get authenticated user from multiple sources:
-    1. FastMCP Context state (set by middleware) - PREFERRED
-    2. HTTP request API key extraction (fallback)
-    3. Environment variable (fallback for testing)
-    4. SKIP_AUTH bypass (development only)
-
-    Args:
-        ctx: Optional FastMCP Context object from tool function
-
-    Returns:
-        User info dict with user_id, email, scopes, name or None if not authenticated
-    """
-    try:
-        # METHOD 1: Get user from FastMCP Context state (set by middleware)
-        # This is the preferred method when using FastMCP middleware
-        if ctx is not None:
-            try:
-                user_id = ctx.get_state("user_id")
-                if user_id:
-                    return {
-                        'user_id': user_id,
-                        'email': ctx.get_state("user_email") or "",
-                        'scopes': ctx.get_state("user_scopes") or [],
-                        'name': ctx.get_state("user_name") or ""
-                    }
-            except Exception:
-                pass  # Context state not available, try other methods
-
-        # METHOD 2: Extract API key from current HTTP request
-        api_key = extract_api_key_from_request()
-
-        # METHOD 3: Fallback to environment variable for testing
-        if not api_key:
-            api_key = os.getenv("FLEETMIND_API_KEY")
-            if api_key:
-                logger.debug("Using API key from environment")
-
-        # Validate the API key
-        if api_key:
-            from database.api_keys import verify_api_key
-            user_info = verify_api_key(api_key)
-            if user_info:
-                logger.info(f"✅ Authenticated: {user_info['email']} (user_id: {user_info['user_id']})")
-                return user_info
-            else:
-                logger.warning(f"❌ Invalid API key: {api_key[:10]}...")
-                return None
-
-        # METHOD 4: Development bypass mode (local testing only)
-        # SECURITY: Only allow SKIP_AUTH in development environments
-        # Check both ENV and ENVIRONMENT variables for compatibility
-        env = os.getenv("ENV") or os.getenv("ENVIRONMENT", "production")
-        env = env.lower()
-        skip_auth = os.getenv("SKIP_AUTH", "false").lower() == "true"
-
-        if skip_auth:
-            if env == "production":
-                logger.error("⚠️ SKIP_AUTH is enabled but ENV=production - DENYING access for security")
-                return None
-            else:
-                logger.warning(f"⚠️ SKIP_AUTH enabled in {env} environment - using development user")
-                return {
-                    'user_id': 'dev-user',
-                    'email': 'dev@fleetmind.local',
-                    'scopes': ['admin'],
-                    'name': 'Development User'
-                }
-
-        return None
-
-    except Exception as e:
-        logger.error(f"Authentication error: {e}")
-        return None
-
-# ============================================================================
-# MCP RESOURCES
-# ============================================================================
-
-@mcp.resource("orders://all")
-def get_orders_resource() -> str:
-    """
-    Real-time orders dataset for AI context.
-    Returns authenticated user's orders from the last 30 days.
-
-    Returns:
-        JSON string containing orders array with key fields:
-        - order_id, customer_name, delivery_address
-        - status, priority, created_at, assigned_driver_id
-    """
-    try:
-        # Authenticate user
-        user = get_authenticated_user()
-        if not user:
-            logger.warning("Resource orders://all - Authentication required")
-            return json.dumps({
-                "error": "Authentication required",
-                "message": "Please provide a valid API key to access orders"
-            })
-
-        # Query only this user's orders
-        query = """
-            SELECT order_id, customer_name, delivery_address,
-                   status, priority, created_at, assigned_driver_id
-            FROM orders
-            WHERE user_id = %s
-              AND created_at > NOW() - INTERVAL '30 days'
-            ORDER BY created_at DESC
-            LIMIT 1000
-        """
-        orders = execute_query(query, (user['user_id'],))
-        logger.info(f"Resource orders://all - User {user['user_id']} retrieved {len(orders) if orders else 0} orders")
-        return json.dumps(orders, default=str, indent=2)
-    except Exception as e:
-        logger.error(f"Resource orders://all failed: {e}")
-        return json.dumps({"error": str(e)})
-
-
-@mcp.resource("drivers://all")
-def get_drivers_resource() -> str:
-    """
-    Real-time drivers dataset for AI context.
-    Returns authenticated user's drivers with current locations and status.
-
-    Returns:
-        JSON string containing drivers array with key fields:
-        - driver_id, name, status, vehicle_type, vehicle_plate
-        - current_lat, current_lng, last_location_update
-    """
-    try:
-        # Authenticate user
-        user = get_authenticated_user()
-        if not user:
-            logger.warning("Resource drivers://all - Authentication required")
-            return json.dumps({
-                "error": "Authentication required",
-                "message": "Please provide a valid API key to access drivers"
-            })
-
-        # Query only this user's drivers
-        query = """
-            SELECT driver_id, name, status, vehicle_type, vehicle_plate,
-                   current_lat, current_lng, last_location_update
-            FROM drivers
-            WHERE user_id = %s
-            ORDER BY name ASC
-        """
-        drivers = execute_query(query, (user['user_id'],))
-        logger.info(f"Resource drivers://all - User {user['user_id']} retrieved {len(drivers) if drivers else 0} drivers")
-        return json.dumps(drivers, default=str, indent=2)
-    except Exception as e:
-        logger.error(f"Resource drivers://all failed: {e}")
-        return json.dumps({"error": str(e)})
-
-
-# ============================================================================
-# MCP PROMPTS (Workflows)
-# ============================================================================
-
-# TODO: Add prompts once FastMCP prompt API is confirmed
-# Prompts will provide guided workflows for:
-# - create_order_workflow: Interactive order creation with validation
-# - assign_driver_workflow: Smart driver assignment with route optimization
-# - order_status_check: Quick order status queries
-
-
-# ============================================================================
-# MCP TOOLS - ORDER CREATION & VALIDATION
-# ============================================================================
-
-@mcp.tool()
-def geocode_address(address: str) -> dict:
-    """
-    Convert a delivery address to GPS coordinates and validate the address format.
-    Use this before creating an order to ensure the address is valid.
-
-    Args:
-        address: The full delivery address to geocode (e.g., '123 Main St, San Francisco, CA')
-
-    Returns:
-        dict: {
-            success: bool,
-            latitude: float,
-            longitude: float,
-            formatted_address: str,
-            confidence: str (high/medium/low),
-            message: str
-        }
-    """
-    from chat.tools import handle_geocode_address
-    logger.info(f"Tool: geocode_address('{address}')")
-    return handle_geocode_address({"address": address})
-
-
-@mcp.tool()
-def calculate_route(
-    origin: str,
-    destination: str,
-    mode: Literal["driving", "walking", "bicycling", "transit"] = "driving",
-    vehicle_type: Literal["car", "van", "truck", "motorcycle", "bicycle"] = "car",
-    alternatives: bool = False,
-    include_steps: bool = False,
-    avoid_tolls: bool = False,
-    avoid_highways: bool = False,
-    avoid_ferries: bool = False,
-    emission_type: Literal["GASOLINE", "ELECTRIC", "HYBRID", "DIESEL"] = "GASOLINE",
-    request_fuel_efficient: bool = False
-) -> dict:
-    """
-    Calculate the shortest route between two locations with vehicle-specific optimization.
-    Uses Google Routes API for accurate real-time traffic, toll info, and fuel consumption.
-
-    Args:
-        origin: Starting location - either full address or coordinates as 'lat,lng'
-        destination: Destination location - either full address or coordinates as 'lat,lng'
-        mode: Travel mode for route calculation (default: driving)
-        vehicle_type: Type of vehicle for route optimization (default: car)
-            - motorcycle: Uses TWO_WHEELER mode for motorcycle-specific routing
-            - bicycle: Uses bike lanes and paths
-            - car/van/truck: Uses DRIVE mode (no truck-specific routing available)
-        alternatives: Return multiple route options if available (default: false)
-        include_steps: Include turn-by-turn navigation steps in response (default: false)
-        avoid_tolls: Avoid toll roads (for cars and motorcycles) (default: false)
-        avoid_highways: Avoid highways (for cars and motorcycles) (default: false)
-        avoid_ferries: Avoid ferry routes (for cars and motorcycles) (default: false)
-        emission_type: Vehicle emission type for eco-routing (cars/vans/trucks only) (default: GASOLINE)
-        request_fuel_efficient: Request eco-friendly route alternative (cars/vans/trucks only) (default: false)
-
-    Returns:
-        dict: {
-            success: bool,
-            origin: str,
-            destination: str,
-            distance: {meters: int, text: str},
-            duration: {seconds: int, text: str} (without traffic),
-            duration_in_traffic: {seconds: int, text: str} (with traffic),
-            traffic_delay: {seconds: int, text: str},
-            mode: str,
-            vehicle_type: str,
-            route_summary: str,
-            route_labels: list,
-            confidence: str,
-            toll_info: {has_tolls: bool, details: str} (if applicable),
-            fuel_consumption: {liters: float, text: str} (if DRIVE mode),
-            traffic_data_available: bool,
-            warning: str (if TWO_WHEELER or BICYCLE mode),
-            steps: list (if include_steps=True)
-        }
-    """
-    from chat.tools import handle_calculate_route
-    logger.info(f"Tool: calculate_route('{origin}' -> '{destination}', vehicle={vehicle_type}, mode={mode})")
-    return handle_calculate_route({
-        "origin": origin,
-        "destination": destination,
-        "mode": mode,
-        "vehicle_type": vehicle_type,
-        "alternatives": alternatives,
-        "include_steps": include_steps,
-        "avoid_tolls": avoid_tolls,
-        "avoid_highways": avoid_highways,
-        "avoid_ferries": avoid_ferries,
-        "emission_type": emission_type,
-        "request_fuel_efficient": request_fuel_efficient
-    })
-
-
-@mcp.tool()
-def calculate_intelligent_route(
-    origin: str,
-    destination: str,
-    vehicle_type: Literal["car", "van", "truck", "motorcycle"] = "car",
-    consider_weather: bool = True,
-    consider_traffic: bool = True
-) -> dict:
-    """
-    Calculate the optimal route considering real-time traffic, weather conditions, and vehicle type.
-    This is an intelligent routing tool that factors in:
-    - Real-time traffic delays
-    - Weather conditions (rain, visibility, wind)
-    - Vehicle-specific capabilities (motorcycle vs car vs truck)
-    - Safety warnings and recommendations
-
-    Use this when you need smart routing that accounts for current conditions.
-
-    Args:
-        origin: Starting location - either full address or coordinates as 'lat,lng'
-        destination: Destination location - either full address or coordinates as 'lat,lng'
-        vehicle_type: Type of vehicle for route optimization (default: car)
-        consider_weather: Factor in weather conditions (default: true)
-        consider_traffic: Factor in real-time traffic (default: true)
-
-    Returns:
-        dict: {
-            success: bool,
-            route: {
-                origin: str,
-                destination: str,
-                distance: {meters: int, text: str},
-                vehicle_type: str,
-                route_summary: str
-            },
-            timing: {
-                base_duration: {seconds: int, text: str},
-                with_traffic: {seconds: int, text: str},
-                adjusted_duration: {seconds: int, text: str},
-                traffic_delay_percent: int,
-                weather_delay_percent: int,
-                total_delay_percent: int
-            },
-            conditions: {
-                traffic_status: str (clear|light|moderate|heavy|severe),
-                weather_considered: bool
-            },
-            weather: {
-                conditions: str,
-                temperature_c: float,
-                precipitation_mm: float,
-                visibility_m: int,
-                impact_severity: str (none|minor|moderate|severe)
-            },
-            recommendations: list[str],
-            warnings: list[str],
-            alternatives: list (if available)
-        }
-
-    Examples:
-        - "Find the best route from SF to Oakland for a motorcycle considering weather"
-        - "What's the fastest route from downtown to airport with current traffic?"
-        - "Calculate delivery route for a truck from warehouse to customer address"
-    """
-    from chat.route_optimizer import calculate_intelligent_route as calc_route
-    logger.info(f"Tool: calculate_intelligent_route('{origin}' -> '{destination}', vehicle={vehicle_type})")
-    return calc_route(origin, destination, vehicle_type, consider_weather, consider_traffic)
-
-
-@mcp.tool()
-def create_order(
-    customer_name: str,
-    delivery_address: str,
-    delivery_lat: float,
-    delivery_lng: float,
-    expected_delivery_time: str,
-    customer_phone: str | None = None,
-    customer_email: str | None = None,
-    priority: Literal["standard", "express", "urgent"] = "standard",
-    weight_kg: float = 5.0,
-    special_instructions: str | None = None,
-    sla_grace_period_minutes: int = 15,
-    time_window_end: str | None = None
-) -> dict:
-    """
-    Create a new delivery order in the database with MANDATORY delivery deadline.
-
-    IMPORTANT: expected_delivery_time is REQUIRED. This is the promised delivery time to the customer.
-    Only call this after geocoding the address successfully.
-
-    Args:
-        customer_name: Full name of the customer
-        delivery_address: Complete delivery address
-        delivery_lat: Latitude from geocoding
-        delivery_lng: Longitude from geocoding
-        expected_delivery_time: REQUIRED - Promised delivery deadline in ISO 8601 format
-                               Must be future timestamp. Examples:
-                               - '2025-11-15T18:00:00' (6 PM today)
-                               - '2025-11-16T12:00:00' (noon tomorrow)
-        customer_phone: Customer phone number (optional)
-        customer_email: Customer email address (optional)
-        priority: Delivery priority level (default: standard)
-        weight_kg: Package weight in kilograms (default: 5.0)
-        special_instructions: Special delivery instructions (optional)
-        sla_grace_period_minutes: Grace period after deadline (default: 15 mins)
-                                  Deliveries within grace period marked as 'late' but acceptable
-        time_window_end: Legacy field, defaults to expected_delivery_time if not provided
-
-    Returns:
-        dict: {
-            success: bool,
-            order_id: str,
-            status: str,
-            customer: str,
-            address: str,
-            expected_delivery: str (new),
-            sla_grace_period_minutes: int (new),
-            priority: str,
-            message: str
-        }
-    """
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {
-            "success": False,
-            "error": "Authentication required. Please login first.",
-            "auth_required": True
-        }
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('create_order')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {
-            "success": False,
-            "error": f"Permission denied. Required scope: {required_scope}"
-        }
-
-    # STEP 3: Execute tool with user_id
-    from chat.tools import handle_create_order
-    logger.info(f"Tool: create_order by user {user.get('email')} (customer='{customer_name}')")
-
-    return handle_create_order(
-        tool_input={
-            "customer_name": customer_name,
-            "delivery_address": delivery_address,
-            "delivery_lat": delivery_lat,
-            "delivery_lng": delivery_lng,
-            "expected_delivery_time": expected_delivery_time,
-            "customer_phone": customer_phone,
-            "customer_email": customer_email,
-            "priority": priority,
-            "weight_kg": weight_kg,
-            "special_instructions": special_instructions,
-            "sla_grace_period_minutes": sla_grace_period_minutes,
-            "time_window_end": time_window_end
-        },
-        user_id=user['user_id']  # Pass user_id for data isolation
-    )
-
-
-# ============================================================================
-# MCP TOOLS - ORDER QUERYING
-# ============================================================================
-
-@mcp.tool()
-def count_orders(
-    status: Literal["pending", "assigned", "in_transit", "delivered", "failed", "cancelled"] | None = None,
-    priority: Literal["standard", "express", "urgent"] | None = None,
-    payment_status: Literal["pending", "paid", "cod"] | None = None,
-    assigned_driver_id: str | None = None,
-    is_fragile: bool | None = None,
-    requires_signature: bool | None = None,
-    requires_cold_storage: bool | None = None
-) -> dict:
-    """
-    Count total orders in the database with optional filters.
-    Use this when user asks 'how many orders', 'fetch orders', or wants to know order statistics.
-
-    Args:
-        status: Filter by order status (optional)
-        priority: Filter by priority level (optional)
-        payment_status: Filter by payment status (optional)
-        assigned_driver_id: Filter by assigned driver ID (optional)
-        is_fragile: Filter fragile packages only (optional)
-        requires_signature: Filter orders requiring signature (optional)
-        requires_cold_storage: Filter orders requiring cold storage (optional)
-
-    Returns:
-        dict: {
-            success: bool,
-            total: int,
-            status_breakdown: dict,
-            priority_breakdown: dict,
-            message: str
-        }
-    """
-    from chat.tools import handle_count_orders
-    logger.info(f"Tool: count_orders(status={status}, priority={priority})")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('count_orders')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    tool_input = {}
-    if status is not None:
-        tool_input["status"] = status
-    if priority is not None:
-        tool_input["priority"] = priority
-    if payment_status is not None:
-        tool_input["payment_status"] = payment_status
-    if assigned_driver_id is not None:
-        tool_input["assigned_driver_id"] = assigned_driver_id
-    if is_fragile is not None:
-        tool_input["is_fragile"] = is_fragile
-    if requires_signature is not None:
-        tool_input["requires_signature"] = requires_signature
-    if requires_cold_storage is not None:
-        tool_input["requires_cold_storage"] = requires_cold_storage
-    return handle_count_orders(tool_input, user_id=user['user_id'])
-
-
-@mcp.tool()
-def fetch_orders(
-    limit: int = 10,
-    offset: int = 0,
-    status: Literal["pending", "assigned", "in_transit", "delivered", "failed", "cancelled"] | None = None,
-    priority: Literal["standard", "express", "urgent"] | None = None,
-    payment_status: Literal["pending", "paid", "cod"] | None = None,
-    assigned_driver_id: str | None = None,
-    is_fragile: bool | None = None,
-    requires_signature: bool | None = None,
-    requires_cold_storage: bool | None = None,
-    sort_by: Literal["created_at", "priority", "time_window_start"] = "created_at",
-    sort_order: Literal["ASC", "DESC"] = "DESC"
-) -> dict:
-    """
-    Fetch orders from the database with optional filters, pagination, and sorting.
-    Use after counting to show specific number of orders.
-
-    Args:
-        limit: Number of orders to fetch (default: 10, max: 100)
-        offset: Number of orders to skip for pagination (default: 0)
-        status: Filter by order status (optional)
-        priority: Filter by priority level (optional)
-        payment_status: Filter by payment status (optional)
-        assigned_driver_id: Filter by assigned driver ID (optional)
-        is_fragile: Filter fragile packages only (optional)
-        requires_signature: Filter orders requiring signature (optional)
-        requires_cold_storage: Filter orders requiring cold storage (optional)
-        sort_by: Field to sort by (default: created_at)
-        sort_order: Sort order (default: DESC for newest first)
-
-    Returns:
-        dict: {
-            success: bool,
-            orders: list[dict],
-            count: int,
-            message: str
-        }
-    """
-    from chat.tools import handle_fetch_orders
-    logger.info(f"Tool: fetch_orders(limit={limit}, offset={offset}, status={status})")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('fetch_orders')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    tool_input = {
-        "limit": limit,
-        "offset": offset,
-        "sort_by": sort_by,
-        "sort_order": sort_order
-    }
-    if status is not None:
-        tool_input["status"] = status
-    if priority is not None:
-        tool_input["priority"] = priority
-    if payment_status is not None:
-        tool_input["payment_status"] = payment_status
-    if assigned_driver_id is not None:
-        tool_input["assigned_driver_id"] = assigned_driver_id
-    if is_fragile is not None:
-        tool_input["is_fragile"] = is_fragile
-    if requires_signature is not None:
-        tool_input["requires_signature"] = requires_signature
-    if requires_cold_storage is not None:
-        tool_input["requires_cold_storage"] = requires_cold_storage
-    return handle_fetch_orders(tool_input, user_id=user['user_id'])
-
-
-@mcp.tool()
-def get_order_details(order_id: str) -> dict:
-    """
-    Get complete details of a specific order by order ID.
-    Use when user asks 'tell me about order X' or wants detailed information about a specific order.
-
-    Args:
-        order_id: The order ID to fetch details for (e.g., 'ORD-20251114163800')
-
-    Returns:
-        dict: {
-            success: bool,
-            order: dict (with all 26 fields),
-            message: str
-        }
-    """
-    from chat.tools import handle_get_order_details
-    logger.info(f"Tool: get_order_details(order_id='{order_id}')")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('get_order_details')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    return handle_get_order_details({"order_id": order_id}, user_id=user['user_id'])
-
-
-@mcp.tool()
-def search_orders(search_term: str) -> dict:
-    """
-    Search for orders by customer name, email, phone, or order ID pattern.
-    Use when user provides partial information to find orders.
-
-    Args:
-        search_term: Search term to match against customer_name, customer_email, customer_phone, or order_id
-
-    Returns:
-        dict: {
-            success: bool,
-            orders: list[dict],
-            count: int,
-            message: str
-        }
-    """
-    from chat.tools import handle_search_orders
-    logger.info(f"Tool: search_orders(search_term='{search_term}')")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('search_orders')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    return handle_search_orders({"search_term": search_term}, user_id=user['user_id'])
-
-
-@mcp.tool()
-def get_incomplete_orders(limit: int = 20) -> dict:
-    """
-    Get all orders that are not yet completed (excludes delivered and cancelled orders).
-    Shortcut for finding orders in progress (pending, assigned, in_transit).
-
-    Args:
-        limit: Number of orders to fetch (default: 20)
-
-    Returns:
-        dict: {
-            success: bool,
-            orders: list[dict],
-            count: int,
-            message: str
-        }
-    """
-    from chat.tools import handle_get_incomplete_orders
-    logger.info(f"Tool: get_incomplete_orders(limit={limit})")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('get_incomplete_orders')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    return handle_get_incomplete_orders({"limit": limit}, user_id=user['user_id'])
-
-
-# ============================================================================
-# MCP TOOLS - ORDER MANAGEMENT
-# ============================================================================
-
-@mcp.tool()
-def update_order(
-    order_id: str,
-    customer_name: str | None = None,
-    customer_phone: str | None = None,
-    customer_email: str | None = None,
-    delivery_address: str | None = None,
-    delivery_lat: float | None = None,
-    delivery_lng: float | None = None,
-    status: Literal["pending", "assigned", "in_transit", "delivered", "failed", "cancelled"] | None = None,
-    priority: Literal["standard", "express", "urgent"] | None = None,
-    special_instructions: str | None = None,
-    time_window_end: str | None = None,
-    payment_status: Literal["pending", "paid", "cod"] | None = None,
-    weight_kg: float | None = None,
-    order_value: float | None = None
-) -> dict:
-    """
-    Update an existing order's details. You can update any combination of fields.
-    Only provide the fields you want to change. Auto-geocodes if delivery_address updated without coordinates.
-
-    Args:
-        order_id: Order ID to update (e.g., 'ORD-20250114123456')
-        customer_name: Updated customer name (optional)
-        customer_phone: Updated customer phone number (optional)
-        customer_email: Updated customer email address (optional)
-        delivery_address: Updated delivery address (optional)
-        delivery_lat: Updated delivery latitude (required if updating address) (optional)
-        delivery_lng: Updated delivery longitude (required if updating address) (optional)
-        status: Updated order status (optional)
-        priority: Updated priority level (optional)
-        special_instructions: Updated special delivery instructions (optional)
-        time_window_end: Updated delivery deadline (ISO format datetime) (optional)
-        payment_status: Updated payment status (optional)
-        weight_kg: Updated package weight in kilograms (optional)
-        order_value: Updated order value in currency (optional)
-
-    Returns:
-        dict: {
-            success: bool,
-            order_id: str,
-            updated_fields: list[str],
-            message: str
-        }
-    """
-    from chat.tools import handle_update_order
-    logger.info(f"Tool: update_order(order_id='{order_id}')")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('update_order')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    tool_input = {"order_id": order_id}
-    if customer_name is not None:
-        tool_input["customer_name"] = customer_name
-    if customer_phone is not None:
-        tool_input["customer_phone"] = customer_phone
-    if customer_email is not None:
-        tool_input["customer_email"] = customer_email
-    if delivery_address is not None:
-        tool_input["delivery_address"] = delivery_address
-    if delivery_lat is not None:
-        tool_input["delivery_lat"] = delivery_lat
-    if delivery_lng is not None:
-        tool_input["delivery_lng"] = delivery_lng
-    if status is not None:
-        tool_input["status"] = status
-    if priority is not None:
-        tool_input["priority"] = priority
-    if special_instructions is not None:
-        tool_input["special_instructions"] = special_instructions
-    if time_window_end is not None:
-        tool_input["time_window_end"] = time_window_end
-    if payment_status is not None:
-        tool_input["payment_status"] = payment_status
-    if weight_kg is not None:
-        tool_input["weight_kg"] = weight_kg
-    if order_value is not None:
-        tool_input["order_value"] = order_value
-    return handle_update_order(tool_input, user_id=user['user_id'])
-
-
-@mcp.tool()
-def delete_order(order_id: str, confirm: bool) -> dict:
-    """
-    Permanently delete an order from the database. This action cannot be undone. Use with caution.
-
-    Args:
-        order_id: Order ID to delete (e.g., 'ORD-20250114123456')
-        confirm: Must be set to true to confirm deletion
-
-    Returns:
-        dict: {
-            success: bool,
-            order_id: str,
-            message: str
-        }
-    """
-    from chat.tools import handle_delete_order
-    logger.info(f"Tool: delete_order(order_id='{order_id}', confirm={confirm})")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('delete_order')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    return handle_delete_order({"order_id": order_id, "confirm": confirm}, user_id=user['user_id'])
-
-
-# ============================================================================
-# MCP TOOLS - DRIVER CREATION
-# ============================================================================
-
-@mcp.tool()
-def create_driver(
-    name: str,
-    vehicle_type: str,
-    current_address: str,
-    current_lat: float,
-    current_lng: float,
-    phone: str | None = None,
-    email: str | None = None,
-    vehicle_plate: str | None = None,
-    capacity_kg: float = 1000.0,
-    capacity_m3: float = 12.0,
-    skills: list[str] | None = None,
-    status: Literal["active", "busy", "offline", "unavailable"] = "active"
-) -> dict:
-    """
-    Create a new delivery driver in the database. Use this to onboard new drivers to the fleet.
-
-    Args:
-        name: Full name of the driver (REQUIRED)
-        vehicle_type: Type of vehicle: van, truck, car, motorcycle (REQUIRED)
-        current_address: Driver's current location address, e.g. '123 Main St, New York, NY' (REQUIRED)
-        current_lat: Driver's current latitude location (REQUIRED, -90 to 90)
-        current_lng: Driver's current longitude location (REQUIRED, -180 to 180)
-        phone: Driver phone number (optional)
-        email: Driver email address (optional)
-        vehicle_plate: Vehicle license plate number (optional)
-        capacity_kg: Vehicle cargo capacity in kilograms (default: 1000.0)
-        capacity_m3: Vehicle cargo volume in cubic meters (default: 12.0)
-        skills: List of driver skills/certifications: refrigerated, medical_certified, fragile_handler, overnight, express_delivery (optional)
-        status: Driver status (default: active)
-
-    Returns:
-        dict: {
-            success: bool,
-            driver_id: str,
-            name: str,
-            status: str,
-            vehicle_type: str,
-            vehicle_plate: str,
-            capacity_kg: float,
-            skills: list[str],
-            location: {latitude, longitude, address},
-            message: str
-        }
-    """
-    from chat.tools import handle_create_driver
-    logger.info(f"Tool: create_driver(name='{name}', vehicle_type='{vehicle_type}', address='{current_address}', location=({current_lat}, {current_lng}))")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('create_driver')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    return handle_create_driver({
-        "name": name,
-        "phone": phone,
-        "email": email,
-        "vehicle_type": vehicle_type,
-        "vehicle_plate": vehicle_plate,
-        "capacity_kg": capacity_kg,
-        "capacity_m3": capacity_m3,
-        "skills": skills or [],
-        "status": status,
-        "current_address": current_address,
-        "current_lat": current_lat,
-        "current_lng": current_lng
-    }, user_id=user['user_id'])
-
-
-# ============================================================================
-# MCP TOOLS - DRIVER QUERYING
-# ============================================================================
-
-@mcp.tool()
-def count_drivers(
-    status: Literal["active", "busy", "offline", "unavailable"] | None = None,
-    vehicle_type: str | None = None
-) -> dict:
-    """
-    Count total drivers in the database with optional filters.
-    Use this when user asks 'how many drivers', 'show drivers', or wants driver statistics.
-
-    Args:
-        status: Filter by driver status (optional)
-        vehicle_type: Filter by vehicle type: van, truck, car, motorcycle, etc. (optional)
-
-    Returns:
-        dict: {
-            success: bool,
-            total: int,
-            status_breakdown: dict,
-            vehicle_breakdown: dict,
-            message: str
-        }
-    """
-    from chat.tools import handle_count_drivers
-    logger.info(f"Tool: count_drivers(status={status}, vehicle_type={vehicle_type})")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('count_drivers')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    tool_input = {}
-    if status is not None:
-        tool_input["status"] = status
-    if vehicle_type is not None:
-        tool_input["vehicle_type"] = vehicle_type
-    return handle_count_drivers(tool_input, user_id=user['user_id'])
-
-
-@mcp.tool()
-def fetch_drivers(
-    limit: int = 10,
-    offset: int = 0,
-    status: Literal["active", "busy", "offline", "unavailable"] | None = None,
-    vehicle_type: str | None = None,
-    sort_by: Literal["name", "status", "created_at", "last_location_update"] = "name",
-    sort_order: Literal["ASC", "DESC"] = "ASC"
-) -> dict:
-    """
-    Fetch drivers from the database with optional filters, pagination, and sorting.
-    Use after counting to show specific number of drivers.
-
-    Args:
-        limit: Number of drivers to fetch (default: 10, max: 100)
-        offset: Number of drivers to skip for pagination (default: 0)
-        status: Filter by driver status (optional)
-        vehicle_type: Filter by vehicle type: van, truck, car, motorcycle, etc. (optional)
-        sort_by: Field to sort by (default: name)
-        sort_order: Sort order (default: ASC for alphabetical)
-
-    Returns:
-        dict: {
-            success: bool,
-            drivers: list[dict],
-            count: int,
-            message: str
-        }
-    """
-    from chat.tools import handle_fetch_drivers
-    logger.info(f"Tool: fetch_drivers(limit={limit}, offset={offset}, status={status})")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('fetch_drivers')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    tool_input = {
-        "limit": limit,
-        "offset": offset,
-        "sort_by": sort_by,
-        "sort_order": sort_order
-    }
-    if status is not None:
-        tool_input["status"] = status
-    if vehicle_type is not None:
-        tool_input["vehicle_type"] = vehicle_type
-    return handle_fetch_drivers(tool_input, user_id=user['user_id'])
-
-
-@mcp.tool()
-def get_driver_details(driver_id: str) -> dict:
-    """
-    Get complete details of a specific driver by driver ID, including current location
-    (latitude, longitude, and human-readable address via reverse geocoding), contact info,
-    vehicle details, status, and skills. Use when user asks about a driver's location,
-    coordinates, position, or any other driver information.
-
-    Args:
-        driver_id: The driver ID to fetch details for (e.g., 'DRV-20251114163800')
-
-    Returns:
-        dict: {
-            success: bool,
-            driver: dict (with all fields including reverse-geocoded location address),
-            message: str
-        }
-    """
-    from chat.tools import handle_get_driver_details
-    logger.info(f"Tool: get_driver_details(driver_id='{driver_id}')")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('get_driver_details')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    return handle_get_driver_details({"driver_id": driver_id}, user_id=user['user_id'])
-
-
-@mcp.tool()
-def search_drivers(search_term: str) -> dict:
-    """
-    Search for drivers by name, email, phone, vehicle plate, or driver ID pattern.
-    Use when user provides partial information to find drivers.
-
-    Args:
-        search_term: Search term to match against name, email, phone, vehicle_plate, or driver_id
-
-    Returns:
-        dict: {
-            success: bool,
-            drivers: list[dict],
-            count: int,
-            message: str
-        }
-    """
-    from chat.tools import handle_search_drivers
-    logger.info(f"Tool: search_drivers(search_term='{search_term}')")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('search_drivers')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    return handle_search_drivers({"search_term": search_term}, user_id=user['user_id'])
-
-
-@mcp.tool()
-def get_available_drivers(limit: int = 20) -> dict:
-    """
-    Get all drivers that are available for assignment (active or offline status, excludes busy and unavailable).
-    Shortcut for finding drivers ready for dispatch.
-
-    Args:
-        limit: Number of drivers to fetch (default: 20)
-
-    Returns:
-        dict: {
-            success: bool,
-            drivers: list[dict],
-            count: int,
-            message: str
-        }
-    """
-    from chat.tools import handle_get_available_drivers
-    logger.info(f"Tool: get_available_drivers(limit={limit})")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('get_available_drivers')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    return handle_get_available_drivers({"limit": limit}, user_id=user['user_id'])
-
-
-# ============================================================================
-# MCP TOOLS - DRIVER MANAGEMENT
-# ============================================================================
-
-@mcp.tool()
-def update_driver(
-    driver_id: str,
-    name: str | None = None,
-    phone: str | None = None,
-    email: str | None = None,
-    status: Literal["active", "busy", "offline", "unavailable"] | None = None,
-    vehicle_type: str | None = None,
-    vehicle_plate: str | None = None,
-    capacity_kg: float | None = None,
-    capacity_m3: float | None = None,
-    skills: list[str] | None = None,
-    current_address: str | None = None,
-    current_lat: float | None = None,
-    current_lng: float | None = None
-) -> dict:
-    """
-    Update an existing driver's details. You can update any combination of fields.
-    Only provide the fields you want to change. Auto-updates last_location_update if coordinates changed.
-
-    Args:
-        driver_id: Driver ID to update (e.g., 'DRV-20250114123456')
-        name: Updated driver name (optional)
-        phone: Updated phone number (optional)
-        email: Updated email address (optional)
-        status: Updated driver status (optional)
-        vehicle_type: Updated vehicle type (optional)
-        vehicle_plate: Updated vehicle license plate (optional)
-        capacity_kg: Updated cargo capacity in kilograms (optional)
-        capacity_m3: Updated cargo capacity in cubic meters (optional)
-        skills: Updated list of driver skills/certifications (optional)
-        current_address: Updated current location address (optional)
-        current_lat: Updated current latitude (optional)
-        current_lng: Updated current longitude (optional)
-
-    Returns:
-        dict: {
-            success: bool,
-            driver_id: str,
-            updated_fields: list[str],
-            message: str
-        }
-    """
-    from chat.tools import handle_update_driver
-    logger.info(f"Tool: update_driver(driver_id='{driver_id}')")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('update_driver')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    tool_input = {"driver_id": driver_id}
-    if name is not None:
-        tool_input["name"] = name
-    if phone is not None:
-        tool_input["phone"] = phone
-    if email is not None:
-        tool_input["email"] = email
-    if status is not None:
-        tool_input["status"] = status
-    if vehicle_type is not None:
-        tool_input["vehicle_type"] = vehicle_type
-    if vehicle_plate is not None:
-        tool_input["vehicle_plate"] = vehicle_plate
-    if capacity_kg is not None:
-        tool_input["capacity_kg"] = capacity_kg
-    if capacity_m3 is not None:
-        tool_input["capacity_m3"] = capacity_m3
-    if skills is not None:
-        tool_input["skills"] = skills
-    if current_address is not None:
-        tool_input["current_address"] = current_address
-    if current_lat is not None:
-        tool_input["current_lat"] = current_lat
-    if current_lng is not None:
-        tool_input["current_lng"] = current_lng
-    return handle_update_driver(tool_input, user_id=user['user_id'])
-
-
-@mcp.tool()
-def delete_driver(driver_id: str, confirm: bool) -> dict:
-    """
-    Permanently delete a driver from the database. This action cannot be undone. Use with caution.
-
-    Args:
-        driver_id: Driver ID to delete (e.g., 'DRV-20250114123456')
-        confirm: Must be set to true to confirm deletion
-
-    Returns:
-        dict: {
-            success: bool,
-            driver_id: str,
-            message: str
-        }
-    """
-    from chat.tools import handle_delete_driver
-    logger.info(f"Tool: delete_driver(driver_id='{driver_id}', confirm={confirm})")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('delete_driver')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    return handle_delete_driver({"driver_id": driver_id, "confirm": confirm}, user_id=user['user_id'])
-
-
-@mcp.tool()
-def delete_all_orders(confirm: bool, status: str = None) -> dict:
-    """
-    Bulk delete all orders (or orders with specific status). DANGEROUS - Use with extreme caution!
-
-    Safety checks:
-    - Requires confirm=true
-    - Blocks deletion if any active assignments exist
-    - Optional status filter to delete only specific statuses
-
-    Args:
-        confirm: Must be set to true to confirm bulk deletion
-        status: Optional status filter (pending/assigned/in_transit/delivered/failed/cancelled)
-
-    Returns:
-        dict: {
-            success: bool,
-            deleted_count: int,
-            message: str
-        }
-    """
-    from chat.tools import handle_delete_all_orders
-    logger.info(f"Tool: delete_all_orders(confirm={confirm}, status='{status}')")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('delete_all_orders')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    return handle_delete_all_orders({"confirm": confirm, "status": status}, user_id=user['user_id'])
-
-
-@mcp.tool()
-def delete_all_drivers(confirm: bool, status: str = None) -> dict:
-    """
-    Bulk delete all drivers (or drivers with specific status). DANGEROUS - Use with extreme caution!
-
-    Safety checks:
-    - Requires confirm=true
-    - Blocks deletion if ANY assignments exist (due to RESTRICT constraint)
-    - Optional status filter to delete only specific statuses
-
-    Args:
-        confirm: Must be set to true to confirm bulk deletion
-        status: Optional status filter (active/busy/offline/unavailable)
-
-    Returns:
-        dict: {
-            success: bool,
-            deleted_count: int,
-            message: str
-        }
-    """
-    from chat.tools import handle_delete_all_drivers
-    logger.info(f"Tool: delete_all_drivers(confirm={confirm}, status='{status}')")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('delete_all_drivers')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    return handle_delete_all_drivers({"confirm": confirm, "status": status}, user_id=user['user_id'])
-
-
-# ============================================================================
-# ASSIGNMENT TOOLS
-# ============================================================================
-
-@mcp.tool()
-def create_assignment(order_id: str, driver_id: str) -> dict:
-    """
-    Assign an order to a driver. Creates an assignment record with route data from driver location to delivery location.
-
-    Requirements:
-    - Order must be in 'pending' status
-    - Driver must be in 'active' or 'available' status
-    - Order cannot already have an active assignment
-
-    After assignment:
-    - Order status changes to 'assigned'
-    - Driver status changes to 'busy'
-    - Route data (distance, duration, path) is calculated and saved
-    - Assignment record is created with all route details
-
-    Args:
-        order_id: Order ID to assign (e.g., 'ORD-20250114123456')
-        driver_id: Driver ID to assign (e.g., 'DRV-20250114123456')
-
-    Returns:
-        dict: {
-            success: bool,
-            assignment_id: str,
-            order_id: str,
-            driver_id: str,
-            route: {
-                distance: {meters: int, text: str},
-                duration: {seconds: int, text: str},
-                route_summary: str,
-                driver_start: {lat: float, lng: float},
-                delivery_location: {lat: float, lng: float, address: str}
-            }
-        }
-    """
-    from chat.tools import handle_create_assignment
-    logger.info(f"Tool: create_assignment(order_id='{order_id}', driver_id='{driver_id}')")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('create_assignment')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    return handle_create_assignment({"order_id": order_id, "driver_id": driver_id}, user_id=user['user_id'])
-
-
-@mcp.tool()
-def auto_assign_order(order_id: str) -> dict:
-    """
-    Automatically assign order to the nearest available driver (distance + validation based).
-
-    Selection Criteria (Auto Algorithm):
-    1. Driver must be 'active' with valid location
-    2. Driver vehicle capacity must meet package weight/volume requirements
-    3. Driver must have required skills (fragile handling, cold storage, etc.)
-    4. Selects nearest driver by real-time route distance
-
-    This is a fixed-rule algorithm that prioritizes proximity while ensuring
-    the driver has the necessary capacity and skills for the delivery.
-
-    After assignment:
-    - Order status changes to 'assigned'
-    - Driver status changes to 'busy'
-    - Route data (distance, duration, path) is calculated and saved
-    - Assignment record is created with all route details
-
-    Args:
-        order_id: Order ID to auto-assign (e.g., 'ORD-20250114123456')
-
-    Returns:
-        dict: {
-            success: bool,
-            assignment_id: str,
-            method: 'auto_assignment',
-            order_id: str,
-            driver_id: str,
-            driver_name: str,
-            driver_phone: str,
-            driver_vehicle_type: str,
-            selection_reason: str,
-            distance_km: float,
-            distance_meters: int,
-            estimated_duration_minutes: float,
-            candidates_evaluated: int,
-            suitable_candidates: int,
-            route_summary: str,
-            estimated_arrival: str
-        }
-    """
-    from chat.tools import handle_auto_assign_order
-    logger.info(f"Tool: auto_assign_order(order_id='{order_id}')")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('auto_assign_order')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    return handle_auto_assign_order({"order_id": order_id}, user_id=user['user_id'])
-
-
-@mcp.tool()
-def intelligent_assign_order(order_id: str) -> dict:
-    """
-    Intelligently assign order using Google Gemini 2.0 Flash AI to analyze all parameters and select the best driver.
-
-    Uses Gemini 2.0 Flash (latest model) to evaluate:
-    - Order characteristics (priority, weight, fragility, time constraints, value)
-    - Driver capabilities (location, capacity, skills, vehicle type)
-    - Real-time routing data (distance, traffic delays, tolls)
-    - Weather conditions and impact on delivery
-    - Complex tradeoffs and optimal matching
-
-    The AI considers multiple factors holistically:
-    - Distance efficiency vs skill requirements
-    - Capacity utilization vs delivery urgency
-    - Traffic conditions vs time constraints
-    - Weather safety vs speed requirements
-    - Cost efficiency (tolls, fuel) vs customer satisfaction
-
-    Returns assignment with detailed AI reasoning explaining why the
-    selected driver is the best match for this specific delivery.
-
-    Requirements:
-    - GOOGLE_API_KEY environment variable must be set
-    - Order must be in 'pending' status
-    - At least one active driver with valid location
-
-    After assignment:
-    - Order status changes to 'assigned'
-    - Driver status changes to 'busy'
-    - Route data (distance, duration, path) is calculated and saved
-    - Assignment record is created with all route details
-    - AI reasoning is returned for transparency
-
-    Args:
-        order_id: Order ID to intelligently assign (e.g., 'ORD-20250114123456')
-
-    Returns:
-        dict: {
-            success: bool,
-            assignment_id: str,
-            method: 'intelligent_assignment',
-            ai_provider: 'Google Gemini 2.0 Flash',
-            order_id: str,
-            driver_id: str,
-            driver_name: str,
-            driver_phone: str,
-            driver_vehicle_type: str,
-            distance_km: float,
-            estimated_duration_minutes: float,
-            ai_reasoning: {
-                primary_factors: [str],
-                trade_offs_considered: [str],
-                risk_assessment: str,
-                decision_summary: str
-            },
-            confidence_score: float,
-            alternatives_considered: [{driver_id: str, reason_not_selected: str}],
-            candidates_evaluated: int,
-            route_summary: str,
-            estimated_arrival: str
-        }
-    """
-    from chat.tools import handle_intelligent_assign_order
-    logger.info(f"Tool: intelligent_assign_order(order_id='{order_id}')")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('intelligent_assign_order')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    return handle_intelligent_assign_order({"order_id": order_id}, user_id=user['user_id'])
-
-
-@mcp.tool()
-def get_assignment_details(
-    assignment_id: str = None,
-    order_id: str = None,
-    driver_id: str = None
-) -> dict:
-    """
-    Get assignment details by assignment ID, order ID, or driver ID.
-    Provide at least one parameter to search.
-
-    Args:
-        assignment_id: Assignment ID (e.g., 'ASN-20250114123456')
-        order_id: Order ID to find assignments for (e.g., 'ORD-20250114123456')
-        driver_id: Driver ID to find assignments for (e.g., 'DRV-20250114123456')
-
-    Returns:
-        dict: {
-            success: bool,
-            assignments: [
-                {
-                    assignment_id: str,
-                    order_id: str,
-                    driver_id: str,
-                    customer_name: str,
-                    driver_name: str,
-                    status: str,
-                    route_distance_meters: int,
-                    route_duration_seconds: int,
-                    route_summary: str,
-                    driver_start_location: {lat: float, lng: float},
-                    delivery_location: {lat: float, lng: float, address: str},
-                    estimated_arrival: str,
-                    assigned_at: str,
-                    updated_at: str
-                }
-            ]
-        }
-    """
-    from chat.tools import handle_get_assignment_details
-    logger.info(f"Tool: get_assignment_details(assignment_id='{assignment_id}', order_id='{order_id}', driver_id='{driver_id}')")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('get_assignment_details')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    return handle_get_assignment_details({
-        "assignment_id": assignment_id,
-        "order_id": order_id,
-        "driver_id": driver_id
-    }, user_id=user['user_id'])
-
-
-@mcp.tool()
-def update_assignment(
-    assignment_id: str,
-    status: str = None,
-    actual_arrival: str = None,
-    actual_distance_meters: int = None,
-    notes: str = None
-) -> dict:
-    """
-    Update assignment status or details.
-
-    Valid status transitions:
-    - active → in_progress (driver starts delivery)
-    - in_progress → completed (delivery successful)
-    - in_progress → failed (delivery failed)
-    - active/in_progress → cancelled (assignment cancelled)
-
-    Cascading updates:
-    - completed: order status → 'delivered', driver checks for other assignments
-    - failed: order status → 'failed', driver checks for other assignments
-    - cancelled: order status → 'cancelled', order.assigned_driver_id → NULL, driver → 'active' if no other assignments
-
-    Args:
-        assignment_id: Assignment ID to update (e.g., 'ASN-20250114123456')
-        status: New status (active, in_progress, completed, failed, cancelled)
-        actual_arrival: Actual arrival timestamp (ISO format)
-        actual_distance_meters: Actual distance traveled in meters
-        notes: Additional notes about the assignment
-
-    Returns:
-        dict: {
-            success: bool,
-            assignment_id: str,
-            updated_fields: list,
-            cascading_actions: list,
-            message: str
-        }
-    """
-    from chat.tools import handle_update_assignment
-    logger.info(f"Tool: update_assignment(assignment_id='{assignment_id}', status='{status}')")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('update_assignment')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    return handle_update_assignment({
-        "assignment_id": assignment_id,
-        "status": status,
-        "actual_arrival": actual_arrival,
-        "actual_distance_meters": actual_distance_meters,
-        "notes": notes
-    }, user_id=user['user_id'])
-
-
-@mcp.tool()
-def unassign_order(assignment_id: str, confirm: bool = False) -> dict:
-    """
-    Unassign an order from a driver by deleting the assignment.
-
-    Requirements:
-    - Assignment cannot be in 'in_progress' status (must cancel first using update_assignment)
-    - Requires confirm=true to proceed
-
-    Effects:
-    - Assignment is deleted
-    - Order status changes back to 'pending'
-    - order.assigned_driver_id is set to NULL
-    - Driver status changes to 'active' (if no other assignments)
-
-    Args:
-        assignment_id: Assignment ID to unassign (e.g., 'ASN-20250114123456')
-        confirm: Must be set to true to confirm unassignment
-
-    Returns:
-        dict: {
-            success: bool,
-            assignment_id: str,
-            order_id: str,
-            driver_id: str,
-            message: str
-        }
-    """
-    from chat.tools import handle_unassign_order
-    logger.info(f"Tool: unassign_order(assignment_id='{assignment_id}', confirm={confirm})")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('unassign_order')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    return handle_unassign_order({"assignment_id": assignment_id, "confirm": confirm}, user_id=user['user_id'])
-
-
-@mcp.tool()
-def complete_delivery(
-    assignment_id: str,
-    confirm: bool,
-    actual_distance_meters: int = None,
-    notes: str = None
-) -> dict:
-    """
-    Mark a delivery as successfully completed and automatically update driver location to delivery address.
-
-    This is the primary tool for completing deliveries. It handles all necessary updates:
-    - Marks assignment as 'completed' with timestamp
-    - Updates order status to 'delivered'
-    - **Automatically moves driver location to the delivery address**
-    - Updates driver status to 'active' (if no other assignments)
-    - Records actual distance and notes (optional)
-
-    Requirements:
-    - Assignment must be in 'active' or 'in_progress' status
-    - Delivery location coordinates must exist
-    - Requires confirm=true
-
-    For failed deliveries: Use fail_delivery tool instead.
-
-    Args:
-        assignment_id: Assignment ID to complete (e.g., 'ASN-20250114123456')
-        confirm: Must be set to true to confirm completion
-        actual_distance_meters: Optional actual distance traveled in meters
-        notes: Optional completion notes
-
-    Returns:
-        dict: {
-            success: bool,
-            assignment_id: str,
-            order_id: str,
-            driver_id: str,
-            customer_name: str,
-            driver_name: str,
-            completed_at: str (ISO timestamp),
-            delivery_location: {lat, lng, address},
-            driver_updated: {new_location, location_updated_at},
-            cascading_actions: list[str],
-            message: str
-        }
-    """
-    from chat.tools import handle_complete_delivery
-    logger.info(f"Tool: complete_delivery(assignment_id='{assignment_id}', confirm={confirm})")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('complete_delivery')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    return handle_complete_delivery({
-        "assignment_id": assignment_id,
-        "confirm": confirm,
-        "actual_distance_meters": actual_distance_meters,
-        "notes": notes
-    }, user_id=user['user_id'])
-
-
-@mcp.tool()
-def fail_delivery(
-    assignment_id: str,
-    current_address: str,
-    current_lat: float,
-    current_lng: float,
-    failure_reason: str,
-    confirm: bool,
-    notes: str = None
-) -> dict:
-    """
-    Mark a delivery as failed with mandatory driver location and failure reason.
-
-    IMPORTANT: Driver MUST provide their current location (address + GPS coordinates) and a valid failure reason.
-    This ensures accurate location tracking and proper failure documentation.
-
-    Handles all necessary updates:
-    - Marks assignment as 'failed' with timestamp
-    - Updates order status to 'failed'
-    - **Updates driver location to the reported current position**
-    - Updates driver status to 'active' (if no other assignments)
-    - Records structured failure reason and optional notes
-
-    Valid failure reasons:
-    - customer_not_available: Customer not present or not reachable
-    - wrong_address: Incorrect or invalid delivery address
-    - refused_delivery: Customer refused to accept delivery
-    - damaged_goods: Package damaged during transit
-    - payment_issue: Payment problems (for COD orders)
-    - vehicle_breakdown: Driver's vehicle broke down
-    - access_restricted: Cannot access delivery location
-    - weather_conditions: Severe weather preventing delivery
-    - other: Other reasons (provide details in notes)
-
-    Requirements:
-    - Assignment must be in 'active' or 'in_progress' status
-    - Driver must provide current address and GPS coordinates
-    - Must provide a valid failure_reason from the list above
-    - Requires confirm=true
-
-    Args:
-        assignment_id: Assignment ID to mark as failed (e.g., 'ASN-20250114123456')
-        current_address: Driver's current location address (e.g., '123 Main St, New York, NY')
-        current_lat: Driver's current latitude (-90 to 90)
-        current_lng: Driver's current longitude (-180 to 180)
-        failure_reason: Reason for failure (must be from valid list)
-        confirm: Must be set to true to confirm failure
-        notes: Optional additional details about the failure
-
-    Returns:
-        dict: {
-            success: bool,
-            assignment_id: str,
-            order_id: str,
-            driver_id: str,
-            customer_name: str,
-            driver_name: str,
-            failed_at: str (ISO timestamp),
-            failure_reason: str,
-            failure_reason_display: str (human-readable),
-            delivery_address: str,
-            driver_location: {lat, lng, address, updated_at},
-            cascading_actions: list[str],
-            message: str
-        }
-    """
-    from chat.tools import handle_fail_delivery
-    logger.info(f"Tool: fail_delivery(assignment_id='{assignment_id}', reason='{failure_reason}')")
-
-    # STEP 1: Authenticate user
-    user = get_authenticated_user()
-    if not user:
-        return {"success": False, "error": "Authentication required"}
-
-    # STEP 2: Check permissions
-    required_scope = get_required_scope('fail_delivery')
-    if not check_permission(user.get('scopes', []), required_scope):
-        return {"success": False, "error": "Permission denied"}
-
-    # STEP 3: Execute with user_id
-    return handle_fail_delivery({
-        "assignment_id": assignment_id,
-        "current_address": current_address,
-        "current_lat": current_lat,
-        "current_lng": current_lng,
-        "failure_reason": failure_reason,
-        "confirm": confirm,
-        "notes": notes
-    }, user_id=user['user_id'])
-
-
-# ============================================================================
-# MAIN ENTRY POINT
-# ============================================================================
-
-if __name__ == "__main__":
-    logger.info("=" * 60)
-    logger.info("FleetMind MCP Server v1.0.0")
-    logger.info("=" * 60)
-    logger.info(f"Geocoding: {geocoding_service.get_status()}")
-    logger.info("Tools: 27 tools registered (19 core + 6 assignment + 2 bulk delete)")
-    logger.info("Resources: 2 resources available")
-    logger.info("Prompts: 3 workflow templates")
-    logger.info("Authentication: Multi-tenant API key via URL query params")
-    logger.info("Usage: Connect with ?api_key=YOUR_KEY in the SSE URL")
-    logger.info("Starting MCP server...")
-    mcp.run()

start_with_proxy.py

@@ -1,164 +0,0 @@
-"""
-FleetMind MCP Server with Authentication Proxy
-Launches both the FastMCP server and the authentication proxy.
-
-This script:
-1. Starts FastMCP server on port 7861 (internal)
-2. Starts authentication proxy on port 7860 (public)
-3. Handles graceful shutdown of both processes
-
-Usage:
-    python start_with_proxy.py
-"""
-
-import subprocess
-import sys
-import time
-import signal
-import os
-from pathlib import Path
-
-# Process handles
-fastmcp_process = None
-proxy_process = None
-
-
-def signal_handler(sig, frame):
-    """Handle Ctrl+C gracefully"""
-    print("\n\nShutting down FleetMind MCP Server...")
-
-    if proxy_process:
-        print("  -> Stopping proxy...")
-        proxy_process.terminate()
-        try:
-            proxy_process.wait(timeout=5)
-        except subprocess.TimeoutExpired:
-            proxy_process.kill()
-
-    if fastmcp_process:
-        print("  -> Stopping FastMCP server...")
-        fastmcp_process.terminate()
-        try:
-            fastmcp_process.wait(timeout=5)
-        except subprocess.TimeoutExpired:
-            fastmcp_process.kill()
-
-    print("[OK] FleetMind MCP Server stopped.")
-    sys.exit(0)
-
-
-def main():
-    global fastmcp_process, proxy_process
-
-    # Register signal handler
-    signal.signal(signal.SIGINT, signal_handler)
-    signal.signal(signal.SIGTERM, signal_handler)
-
-    print("\n" + "=" * 70)
-    print("FleetMind MCP Server with Multi-Tenant Authentication")
-    print("=" * 70)
-    print("Starting components:")
-    print("  1. FastMCP Server (port 7861) - Internal")
-    print("  2. Auth Proxy (port 7860) - Public")
-    print("=" * 70 + "\n")
-
-    # Get Python executable
-    python_exe = sys.executable
-
-    # Start FastMCP server
-    print("[1/2] Starting FastMCP server on port 7861...")
-    try:
-        # Don't capture output - let it show in console
-        fastmcp_process = subprocess.Popen(
-            [python_exe, "app.py"]
-        )
-        print("[OK] FastMCP server starting (output below)...")
-    except Exception as e:
-        print(f"[ERROR] Failed to start FastMCP server: {e}")
-        sys.exit(1)
-
-    # Wait a bit for FastMCP to initialize
-    print("   Waiting for FastMCP to initialize...")
-    time.sleep(3)
-
-    # Check if FastMCP is still running
-    if fastmcp_process.poll() is not None:
-        print("[ERROR] FastMCP server failed to start")
-        print("   Check the error messages above")
-        sys.exit(1)
-
-    print("[OK] FastMCP server running")
-
-    # Start proxy
-    print("\n[2/2] Starting authentication proxy on port 7860...")
-    try:
-        # Don't capture output - let it show in console
-        proxy_process = subprocess.Popen(
-            [python_exe, "proxy.py"]
-        )
-        print("[OK] Auth proxy starting (output below)...")
-    except Exception as e:
-        print(f"[ERROR] Failed to start proxy: {e}")
-        if fastmcp_process:
-            fastmcp_process.terminate()
-        sys.exit(1)
-
-    # Wait a bit for proxy to initialize
-    time.sleep(2)
-
-    # Check if proxy is still running
-    if proxy_process.poll() is not None:
-        print("[ERROR] Proxy failed to start")
-        if fastmcp_process:
-            fastmcp_process.terminate()
-        sys.exit(1)
-
-    print("[OK] Auth proxy running")
-
-    print("\n" + "=" * 70)
-    print("[OK] FleetMind MCP Server is READY!")
-    print("=" * 70)
-    print(f"Connect to: http://localhost:7860/sse")
-    print(f"Claude Desktop config:")
-    print(f'   "args": ["mcp-remote", "http://localhost:7860/sse?api_key=YOUR_KEY"]')
-    print("=" * 70)
-    print("\n[AUTH] Multi-tenant authentication is ENABLED")
-    print("   Each connection's API key will be captured automatically\n")
-    print("Press Ctrl+C to stop...\n")
-
-    # Monitor both processes
-    try:
-        while True:
-            # Check FastMCP
-            if fastmcp_process.poll() is not None:
-                print("[ERROR] FastMCP server stopped unexpectedly")
-                if proxy_process:
-                    proxy_process.terminate()
-                sys.exit(1)
-
-            # Check proxy
-            if proxy_process.poll() is not None:
-                print("[ERROR] Proxy stopped unexpectedly")
-                if fastmcp_process:
-                    fastmcp_process.terminate()
-                sys.exit(1)
-
-            # Read and display logs (non-blocking)
-            # This keeps the terminal responsive
-            time.sleep(1)
-
-    except KeyboardInterrupt:
-        signal_handler(signal.SIGINT, None)
-
-
-if __name__ == "__main__":
-    # Check if required files exist
-    if not Path("app.py").exists():
-        print("[ERROR] app.py not found")
-        sys.exit(1)
-
-    if not Path("proxy.py").exists():
-        print("[ERROR] proxy.py not found")
-        sys.exit(1)
-
-    main()

ui/app.py

@@ -1,6 +1,6 @@
 """
 FleetMind MCP - Gradio Web Interface
-Enhanced 3-tab dashboard: Chat, Orders, Drivers
+Simple dashboard to interact with the MCP server and database
 """
 
 import sys
@@ -18,463 +18,283 @@ import json
 from chat.chat_engine import ChatEngine
 from chat.conversation import ConversationManager
 from chat.geocoding import GeocodingService
-import uuid
-
-# Global session storage
-SESSIONS = {}
-
-# Initialize chat engine and geocoding service
-chat_engine = ChatEngine()
-geocoding_service = GeocodingService()
 
 # ============================================
-# STATISTICS FUNCTIONS
+# DATABASE FUNCTIONS
 # ============================================
 
-def get_orders_stats():
-    """Get order statistics by status"""
+def get_database_status():
+    """Check if database is connected"""
     try:
-        query = """
-            SELECT
-                COUNT(*) as total,
-                COUNT(CASE WHEN status = 'pending' THEN 1 END) as pending,
-                COUNT(CASE WHEN status = 'assigned' THEN 1 END) as assigned,
-                COUNT(CASE WHEN status = 'in_transit' THEN 1 END) as in_transit,
-                COUNT(CASE WHEN status = 'delivered' THEN 1 END) as delivered,
-                COUNT(CASE WHEN status = 'failed' THEN 1 END) as failed,
-                COUNT(CASE WHEN status = 'cancelled' THEN 1 END) as cancelled
-            FROM orders
-        """
-        result = execute_query(query)
-        if result:
-            return result[0]
-        return {"total": 0, "pending": 0, "assigned": 0, "in_transit": 0, "delivered": 0, "failed": 0, "cancelled": 0}
+        if test_connection():
+            return "✅ Connected", "success"
+        else:
+            return "❌ Disconnected", "error"
     except Exception as e:
-        print(f"Error getting order stats: {e}")
-        return {"total": 0, "pending": 0, "assigned": 0, "in_transit": 0, "delivered": 0, "failed": 0, "cancelled": 0}
+        return f"❌ Error: {str(e)}", "error"
 
 
-def get_drivers_stats():
-    """Get driver statistics by status"""
+def get_orders_summary():
+    """Get summary of orders by status"""
     try:
         query = """
             SELECT
-                COUNT(*) as total,
-                COUNT(CASE WHEN status = 'active' THEN 1 END) as active,
-                COUNT(CASE WHEN status = 'busy' THEN 1 END) as busy,
-                COUNT(CASE WHEN status = 'offline' THEN 1 END) as offline,
-                COUNT(CASE WHEN status = 'unavailable' THEN 1 END) as unavailable
-            FROM drivers
+                status,
+                COUNT(*) as count
+            FROM orders
+            GROUP BY status
+            ORDER BY count DESC
         """
-        result = execute_query(query)
-        if result:
-            return result[0]
-        return {"total": 0, "active": 0, "busy": 0, "offline": 0, "unavailable": 0}
-    except Exception as e:
-        print(f"Error getting driver stats: {e}")
-        return {"total": 0, "active": 0, "busy": 0, "offline": 0, "unavailable": 0}
-
+        results = execute_query(query)
 
-# ============================================
-# ORDERS FUNCTIONS
-# ============================================
-
-def get_all_orders(status_filter="all", priority_filter="all", payment_filter="all", search_term=""):
-    """Get orders with filters"""
-    try:
-        where_clauses = []
-        params = []
-
-        if status_filter and status_filter != "all":
-            where_clauses.append("status = %s")
-            params.append(status_filter)
-
-        if priority_filter and priority_filter != "all":
-            where_clauses.append("priority = %s")
-            params.append(priority_filter)
+        if not results:
+            return "No orders in database"
 
-        if payment_filter and payment_filter != "all":
-            where_clauses.append("payment_status = %s")
-            params.append(payment_filter)
+        summary = "**Orders Summary:**\n\n"
+        for row in results:
+            summary += f"- {row['status'].upper()}: {row['count']}\n"
 
-        if search_term:
-            where_clauses.append("(order_id ILIKE %s OR customer_name ILIKE %s OR customer_phone ILIKE %s)")
-            search_pattern = f"%{search_term}%"
-            params.extend([search_pattern, search_pattern, search_pattern])
+        return summary
+    except Exception as e:
+        return f"Error: {str(e)}"
 
-        where_sql = " WHERE " + " AND ".join(where_clauses) if where_clauses else ""
 
-        query = f"""
+def get_all_orders():
+    """Get all orders from database"""
+    try:
+        query = """
             SELECT
                 order_id,
                 customer_name,
                 delivery_address,
                 status,
                 priority,
-                assigned_driver_id,
-                time_window_end,
                 created_at
             FROM orders
-            {where_sql}
             ORDER BY created_at DESC
-            LIMIT 100
+            LIMIT 50
         """
-
-        results = execute_query(query, tuple(params) if params else ())
+        results = execute_query(query)
 
         if not results:
-            return [["-", "-", "-", "-", "-", "-", "-"]]
+            return [["No orders found", "", "", "", "", ""]]
 
-        # Format data for table
+        # Convert to list of lists for Gradio dataframe
         data = []
         for row in results:
-            # Truncate address if too long
-            address = row['delivery_address']
-            if len(address) > 40:
-                address = address[:37] + "..."
-
-            # Format deadline
-            deadline = row['time_window_end'].strftime("%Y-%m-%d %H:%M") if row['time_window_end'] else "No deadline"
-
-            # Driver ID or "Unassigned"
-            driver = row['assigned_driver_id'] if row['assigned_driver_id'] else "Unassigned"
-
             data.append([
                 row['order_id'],
                 row['customer_name'],
-                address,
+                row['delivery_address'][:50] + "..." if len(row['delivery_address']) > 50 else row['delivery_address'],
                 row['status'],
                 row['priority'],
-                driver,
-                deadline
+                str(row['created_at'])
             ])
 
         return data
     except Exception as e:
-        print(f"Error fetching orders: {e}")
-        return [[f"Error: {str(e)}", "", "", "", "", "", ""]]
+        return [[f"Error: {str(e)}", "", "", "", "", ""]]
 
 
-def get_order_details(order_id):
-    """Get complete order details"""
-    if not order_id or order_id == "-":
-        return "Select an order from the table to view details"
-
+def create_sample_order():
+    """Create a sample order for testing"""
     try:
+        now = datetime.now()
+        order_id = f"ORD-{now.strftime('%Y%m%d%H%M%S')}"
+
         query = """
-            SELECT * FROM orders WHERE order_id = %s
+            INSERT INTO orders (
+                order_id, customer_name, customer_phone, customer_email,
+                delivery_address, delivery_lat, delivery_lng,
+                time_window_start, time_window_end,
+                priority, weight_kg, status
+            ) VALUES (%s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s, %s)
         """
-        results = execute_query(query, (order_id,))
 
-        if not results:
-            return f"Order {order_id} not found"
-
-        order = results[0]
-
-        # Format the details nicely
-        details = f"""
-# Order Details: {order_id}
-
-## Customer Information
-- **Name:** {order['customer_name']}
-- **Phone:** {order['customer_phone'] or 'N/A'}
-- **Email:** {order['customer_email'] or 'N/A'}
-
-## Delivery Information
-- **Address:** {order['delivery_address']}
-- **Coordinates:** ({order['delivery_lat']}, {order['delivery_lng']})
-- **Time Window:** {order['time_window_start']} to {order['time_window_end']}
-
-## Package Details
-- **Weight:** {order['weight_kg'] or 'N/A'} kg
-- **Volume:** {order['volume_m3'] or 'N/A'} m³
-- **Is Fragile:** {"Yes" if order['is_fragile'] else "No"}
-- **Requires Signature:** {"Yes" if order['requires_signature'] else "No"}
-- **Requires Cold Storage:** {"Yes" if order['requires_cold_storage'] else "No"}
-
-## Order Status
-- **Status:** {order['status']}
-- **Priority:** {order['priority']}
-- **Assigned Driver:** {order['assigned_driver_id'] or 'Unassigned'}
-
-## Payment
-- **Order Value:** ${order['order_value'] or '0.00'}
-- **Payment Status:** {order['payment_status']}
-
-## Special Instructions
-{order['special_instructions'] or 'None'}
-
-## Timestamps
-- **Created:** {order['created_at']}
-- **Updated:** {order['updated_at']}
-- **Delivered:** {order['delivered_at'] or 'Not delivered yet'}
-"""
-        return details
+        params = (
+            order_id,
+            "Sample Customer",
+            "+1-555-0100",
+            "sample@example.com",
+            "456 Sample Street, San Francisco, CA 94103",
+            37.7749,
+            -122.4194,
+            now + timedelta(hours=2),
+            now + timedelta(hours=6),
+            "standard",
+            10.5,
+            "pending"
+        )
 
+        execute_write(query, params)
+        return f"✅ Order {order_id} created successfully!", get_all_orders()
     except Exception as e:
-        return f"Error fetching order details: {str(e)}"
-
+        return f"❌ Error: {str(e)}", get_all_orders()
 
-# ============================================
-# DRIVERS FUNCTIONS
-# ============================================
 
-def get_all_drivers(status_filter="all", vehicle_filter="all", search_term=""):
-    """Get drivers with filters"""
+def search_orders(search_term):
+    """Search orders by customer name or order ID"""
     try:
-        where_clauses = []
-        params = []
+        if not search_term:
+            return get_all_orders()
 
-        if status_filter and status_filter != "all":
-            where_clauses.append("status = %s")
-            params.append(status_filter)
-
-        if vehicle_filter and vehicle_filter != "all":
-            where_clauses.append("vehicle_type = %s")
-            params.append(vehicle_filter)
-
-        if search_term:
-            where_clauses.append("(driver_id ILIKE %s OR name ILIKE %s OR phone ILIKE %s OR vehicle_plate ILIKE %s)")
-            search_pattern = f"%{search_term}%"
-            params.extend([search_pattern, search_pattern, search_pattern, search_pattern])
-
-        where_sql = " WHERE " + " AND ".join(where_clauses) if where_clauses else ""
-
-        query = f"""
+        query = """
             SELECT
-                driver_id,
-                name,
-                phone,
+                order_id,
+                customer_name,
+                delivery_address,
                 status,
-                vehicle_type,
-                vehicle_plate,
-                current_lat,
-                current_lng,
-                last_location_update
-            FROM drivers
-            {where_sql}
-            ORDER BY name ASC
-            LIMIT 100
+                priority,
+                created_at
+            FROM orders
+            WHERE
+                order_id ILIKE %s OR
+                customer_name ILIKE %s
+            ORDER BY created_at DESC
+            LIMIT 50
         """
 
-        results = execute_query(query, tuple(params) if params else ())
+        search_pattern = f"%{search_term}%"
+        results = execute_query(query, (search_pattern, search_pattern))
 
         if not results:
-            return [["-", "-", "-", "-", "-", "-", "-"]]
+            return [["No matching orders found", "", "", "", "", ""]]
 
-        # Format data for table
         data = []
         for row in results:
-            # Format location
-            if row['current_lat'] and row['current_lng']:
-                location = f"{row['current_lat']:.4f}, {row['current_lng']:.4f}"
-            else:
-                location = "No location"
-
-            # Format last update
-            last_update = row['last_location_update'].strftime("%Y-%m-%d %H:%M") if row['last_location_update'] else "Never"
-
             data.append([
-                row['driver_id'],
-                row['name'],
-                row['phone'] or "N/A",
+                row['order_id'],
+                row['customer_name'],
+                row['delivery_address'][:50] + "..." if len(row['delivery_address']) > 50 else row['delivery_address'],
                 row['status'],
-                f"{row['vehicle_type']} - {row['vehicle_plate'] or 'N/A'}",
-                location,
-                last_update
+                row['priority'],
+                str(row['created_at'])
             ])
 
         return data
     except Exception as e:
-        print(f"Error fetching drivers: {e}")
-        return [[f"Error: {str(e)}", "", "", "", "", "", ""]]
-
-
-def get_driver_details(driver_id):
-    """Get complete driver details"""
-    if not driver_id or driver_id == "-":
-        return "Select a driver from the table to view details"
-
-    try:
-        query = """
-            SELECT * FROM drivers WHERE driver_id = %s
-        """
-        results = execute_query(query, (driver_id,))
-
-        if not results:
-            return f"Driver {driver_id} not found"
-
-        driver = results[0]
-
-        # Parse skills (handle both list and JSON string)
-        if driver['skills']:
-            if isinstance(driver['skills'], list):
-                skills = driver['skills']
-            else:
-                skills = json.loads(driver['skills'])
-        else:
-            skills = []
-        skills_str = ", ".join(skills) if skills else "None"
-
-        # Format the details nicely
-        details = f"""
-# Driver Details: {driver_id}
-
-## Personal Information
-- **Name:** {driver['name']}
-- **Phone:** {driver['phone'] or 'N/A'}
-- **Email:** {driver['email'] or 'N/A'}
-
-## Current Location
-- **Coordinates:** ({driver['current_lat']}, {driver['current_lng']})
-- **Last Update:** {driver['last_location_update'] or 'Never updated'}
-
-## Status
-- **Status:** {driver['status']}
-
-## Vehicle Information
-- **Type:** {driver['vehicle_type']}
-- **Plate:** {driver['vehicle_plate'] or 'N/A'}
-- **Capacity (kg):** {driver['capacity_kg'] or 'N/A'}
-- **Capacity (m³):** {driver['capacity_m3'] or 'N/A'}
-
-## Skills & Certifications
-{skills_str}
-
-## Timestamps
-- **Created:** {driver['created_at']}
-- **Updated:** {driver['updated_at']}
-"""
-        return details
-
-    except Exception as e:
-        return f"Error fetching driver details: {str(e)}"
-
-
-def update_order_ui(order_id, **fields):
-    """Update order via UI"""
-    from chat.tools import execute_tool
-
-    if not order_id:
-        return {"success": False, "message": "Order ID is required"}
-
-    # Build tool input
-    tool_input = {"order_id": order_id}
-    tool_input.update(fields)
-
-    # Call update tool
-    result = execute_tool("update_order", tool_input)
-
-    return result
-
-
-def delete_order_ui(order_id):
-    """Delete order via UI"""
-    from chat.tools import execute_tool
-
-    if not order_id:
-        return {"success": False, "message": "Order ID is required"}
-
-    # Call delete tool with confirmation
-    result = execute_tool("delete_order", {"order_id": order_id, "confirm": True})
-
-    return result
-
-
-def update_driver_ui(driver_id, **fields):
-    """Update driver via UI"""
-    from chat.tools import execute_tool
-
-    if not driver_id:
-        return {"success": False, "message": "Driver ID is required"}
-
-    # Build tool input
-    tool_input = {"driver_id": driver_id}
-    tool_input.update(fields)
-
-    # Call update tool
-    result = execute_tool("update_driver", tool_input)
-
-    return result
-
-
-def delete_driver_ui(driver_id):
-    """Delete driver via UI"""
-    from chat.tools import execute_tool
-
-    if not driver_id:
-        return {"success": False, "message": "Driver ID is required"}
-
-    # Call delete tool with confirmation
-    result = execute_tool("delete_driver", {"driver_id": driver_id, "confirm": True})
-
-    return result
+        return [[f"Error: {str(e)}", "", "", "", "", ""]]
 
 
 # ============================================
 # CHAT FUNCTIONS
 # ============================================
 
+# Initialize chat engine and geocoding service
+chat_engine = ChatEngine()
+geocoding_service = GeocodingService()
+
+
 def get_api_status():
     """Get API status for chat"""
+    # Get full status for all providers
     full_status = chat_engine.get_full_status()
     selected = full_status["selected"]
     claude_status = full_status["claude"]["status"]
     gemini_status = full_status["gemini"]["status"]
+
     geocoding_status = geocoding_service.get_status()
 
+    # Mark selected provider
     claude_marker = "🎯 **ACTIVE** - " if selected == "anthropic" else ""
     gemini_marker = "🎯 **ACTIVE** - " if selected == "gemini" else ""
 
-    return f"""**AI Provider:**
+    return f"""### API Status
+
+**AI Provider:**
+
+**Claude (Anthropic):**
+{claude_marker}{claude_status}
+
+**Gemini (Google):**
+{gemini_marker}{gemini_status}
+
+*💡 Switch provider by setting `AI_PROVIDER=anthropic` or `AI_PROVIDER=gemini` in .env*
+
+---
 
-**Claude:** {claude_marker}{claude_status}
-**Gemini:** {gemini_marker}{gemini_status}
+**Geocoding:**
 
-**Geocoding:** {geocoding_status}
+**HERE Maps:**
+{geocoding_status}
 """
 
 
-def handle_chat_message(message, session_id):
-    """Handle chat message from user"""
-    if session_id not in SESSIONS:
-        SESSIONS[session_id] = ConversationManager()
-        welcome = chat_engine.get_welcome_message()
-        SESSIONS[session_id].add_message("assistant", welcome)
+def handle_chat_message(message, conversation_state):
+    """
+    Handle chat message from user
 
-    conversation = SESSIONS[session_id]
+    Args:
+        message: User's message
+        conversation_state: ConversationManager instance
 
+    Returns:
+        Updated chatbot history, tool display, conversation state
+    """
     if not message.strip():
-        return conversation.get_formatted_history(), conversation.get_tool_calls(), session_id
+        return conversation_state.get_formatted_history(), conversation_state.get_tool_calls(), conversation_state
 
-    response, tool_calls = chat_engine.process_message(message, conversation)
-    return conversation.get_formatted_history(), conversation.get_tool_calls(), session_id
+    # Process message through chat engine
+    response, tool_calls = chat_engine.process_message(message, conversation_state)
 
+    # Return updated UI
+    return conversation_state.get_formatted_history(), conversation_state.get_tool_calls(), conversation_state
 
-def reset_conversation(session_id):
+
+def reset_conversation():
     """Reset conversation to start fresh"""
-    new_session_id = str(uuid.uuid4())
     new_conversation = ConversationManager()
+
+    # Add welcome message
     welcome = chat_engine.get_welcome_message()
     new_conversation.add_message("assistant", welcome)
-    SESSIONS[new_session_id] = new_conversation
 
     return (
         new_conversation.get_formatted_history(),
-        [],
-        new_session_id
+        [],  # Clear tool calls
+        new_conversation
     )
 
 
 def get_initial_chat():
     """Get initial chat state with welcome message"""
-    session_id = str(uuid.uuid4())
     conversation = ConversationManager()
     welcome = chat_engine.get_welcome_message()
     conversation.add_message("assistant", welcome)
-    SESSIONS[session_id] = conversation
 
-    return conversation.get_formatted_history(), [], session_id
+    return conversation.get_formatted_history(), [], conversation
+
+
+# ============================================
+# MCP SERVER INFO
+# ============================================
+
+def get_mcp_server_info():
+    """Get MCP server information"""
+    mcp_info = {
+        "server_name": "dispatch-coordinator-mcp",
+        "version": "1.0.0",
+        "status": "Ready",
+        "tools": [
+            "route_optimizer",
+            "geocoder",
+            "weather_monitor",
+            "traffic_checker",
+            "distance_matrix",
+            "order_manager"
+        ]
+    }
+
+    return f"""
+### MCP Server Information
+
+**Name:** {mcp_info['server_name']}
+**Version:** {mcp_info['version']}
+**Status:** 🟢 {mcp_info['status']}
+
+**Available Tools ({len(mcp_info['tools'])}):**
+{chr(10).join([f"- {tool}" for tool in mcp_info['tools']])}
+"""
 
 
 # ============================================
@@ -482,619 +302,212 @@ def get_initial_chat():
 # ============================================
 
 def create_interface():
-    """Create the Gradio interface with 3 enhanced tabs"""
+    """Create the Gradio interface"""
 
-    with gr.Blocks(theme=gr.themes.Soft(), title="FleetMind Dispatch System") as app:
+    with gr.Blocks(theme=gr.themes.Soft(), title="FleetMind MCP Dashboard") as app:
 
-        gr.Markdown("# 🚚 FleetMind Dispatch System")
-        gr.Markdown("*AI-Powered Delivery Coordination*")
+        gr.Markdown("# 🚚 FleetMind MCP Dashboard")
+        gr.Markdown("*Autonomous Dispatch Coordinator powered by MCP and PostgreSQL*")
 
         with gr.Tabs():
 
             # ==========================================
-            # TAB 1: CHAT
+            # TAB 1: OVERVIEW
             # ==========================================
-            with gr.Tab("💬 Chat Assistant"):
-                provider_name = chat_engine.get_provider_name()
-                model_name = chat_engine.get_model_name()
-
-                gr.Markdown(f"### AI Dispatch Assistant")
-                gr.Markdown(f"*Powered by {provider_name} ({model_name})*")
-
-                # Quick Action Buttons
-                gr.Markdown("**Quick Actions:**")
-
-                # Row 1: Create and View
-                with gr.Row():
-                    quick_create_order = gr.Button("📦 Create Order", size="sm")
-                    quick_view_orders = gr.Button("📋 View Orders", size="sm")
-                    quick_view_drivers = gr.Button("👥 View Drivers", size="sm")
-                    quick_check_status = gr.Button("📊 Check Status", size="sm")
-
-                # Row 2: Order Management
+            with gr.Tab("📊 Overview"):
                 with gr.Row():
-                    quick_update_order = gr.Button("✏️ Update Order", size="sm", variant="secondary")
-                    quick_delete_order = gr.Button("🗑️ Delete Order", size="sm", variant="secondary")
-                    quick_update_driver = gr.Button("✏️ Update Driver", size="sm", variant="secondary")
-                    quick_delete_driver = gr.Button("🗑️ Delete Driver", size="sm", variant="secondary")
-
-                # Chat interface
-                chatbot = gr.Chatbot(
-                    label="Chat with AI Assistant",
-                    height=600,
-                    type="messages",
-                    show_copy_button=True,
-                    avatar_images=("👤", "🤖")
-                )
-
-                msg_input = gr.Textbox(
-                    placeholder="Type your message here... (e.g., 'Create order for John at 123 Main St' or 'Show me available drivers')",
-                    label="Your Message",
-                    lines=3
-                )
-
-                with gr.Row():
-                    send_btn = gr.Button("📤 Send Message", variant="primary", scale=3)
-                    clear_btn = gr.Button("🗑️ Clear Chat", scale=1)
-
-                # API Status in accordion
-                with gr.Accordion("🔧 System Status", open=False):
-                    api_status = gr.Markdown(get_api_status())
-
-                # Tool usage display
-                with gr.Accordion("🛠️ Tool Usage Log", open=False):
-                    gr.Markdown("*See what tools the AI is using behind the scenes*")
-                    tool_display = gr.JSON(label="Tools Called", value=[])
-
-                # Session state
-                session_id_state = gr.State(value=None)
-
-                # Event handlers
-                def send_message(message, sess_id):
-                    if sess_id is None:
-                        sess_id = str(uuid.uuid4())
-                        SESSIONS[sess_id] = ConversationManager()
-                        welcome = chat_engine.get_welcome_message()
-                        SESSIONS[sess_id].add_message("assistant", welcome)
-
-                    chat_history, tools, new_sess_id = handle_chat_message(message, sess_id)
-                    return chat_history, tools, new_sess_id, ""
-
-                # Quick action functions
-                def quick_action(prompt):
-                    return prompt
-
-                quick_create_order.click(
-                    fn=lambda: "Create a new order",
-                    outputs=msg_input
-                )
-
-                quick_view_orders.click(
-                    fn=lambda: "Show me all orders",
-                    outputs=msg_input
-                )
-
-                quick_view_drivers.click(
-                    fn=lambda: "Show me all available drivers",
-                    outputs=msg_input
-                )
-
-                quick_check_status.click(
-                    fn=lambda: "What is the current status of orders and drivers?",
-                    outputs=msg_input
-                )
-
-                quick_update_order.click(
-                    fn=lambda: "Update order [ORDER_ID] - change status to [STATUS]",
-                    outputs=msg_input
-                )
-
-                quick_delete_order.click(
-                    fn=lambda: "Delete order [ORDER_ID]",
-                    outputs=msg_input
-                )
-
-                quick_update_driver.click(
-                    fn=lambda: "Update driver [DRIVER_ID] - change status to [STATUS]",
-                    outputs=msg_input
-                )
-
-                quick_delete_driver.click(
-                    fn=lambda: "Delete driver [DRIVER_ID]",
-                    outputs=msg_input
-                )
+                    with gr.Column(scale=1):
+                        gr.Markdown("### System Status")
+                        db_status = gr.Textbox(
+                            label="Database Connection",
+                            value=get_database_status()[0],
+                            interactive=False
+                        )
+                        refresh_status_btn = gr.Button("🔄 Refresh Status", size="sm")
 
-                send_btn.click(
-                    fn=send_message,
-                    inputs=[msg_input, session_id_state],
-                    outputs=[chatbot, tool_display, session_id_state, msg_input]
-                )
+                        gr.Markdown("---")
+                        orders_summary = gr.Markdown(get_orders_summary())
 
-                msg_input.submit(
-                    fn=send_message,
-                    inputs=[msg_input, session_id_state],
-                    outputs=[chatbot, tool_display, session_id_state, msg_input]
-                )
+                    with gr.Column(scale=2):
+                        mcp_info = gr.Markdown(get_mcp_server_info())
 
-                clear_btn.click(
-                    fn=reset_conversation,
-                    inputs=[session_id_state],
-                    outputs=[chatbot, tool_display, session_id_state]
+                # Refresh status button action
+                refresh_status_btn.click(
+                    fn=lambda: get_database_status()[0],
+                    outputs=db_status
                 )
 
             # ==========================================
-            # TAB 2: ORDERS
+            # TAB 2: ORDERS MANAGEMENT
             # ==========================================
-            with gr.Tab("📦 Orders Management"):
-                gr.Markdown("### Orders Dashboard")
-
-                # Statistics Cards
-                def update_order_stats():
-                    stats = get_orders_stats()
-                    return (
-                        f"**Total:** {stats['total']}",
-                        f"**Pending:** {stats['pending']}",
-                        f"**In Transit:** {stats['in_transit']}",
-                        f"**Delivered:** {stats['delivered']}"
-                    )
-
-                with gr.Row():
-                    stat_total = gr.Markdown("**Total:** 0")
-                    stat_pending = gr.Markdown("**Pending:** 0")
-                    stat_transit = gr.Markdown("**In Transit:** 0")
-                    stat_delivered = gr.Markdown("**Delivered:** 0")
-
-                gr.Markdown("---")
+            with gr.Tab("📦 Orders"):
+                gr.Markdown("### Orders Management")
 
-                # Filters
-                gr.Markdown("**Filters:**")
                 with gr.Row():
-                    status_filter = gr.Dropdown(
-                        choices=["all", "pending", "assigned", "in_transit", "delivered", "failed", "cancelled"],
-                        value="all",
-                        label="Status",
-                        scale=1
-                    )
-                    priority_filter = gr.Dropdown(
-                        choices=["all", "standard", "express", "urgent"],
-                        value="all",
-                        label="Priority",
-                        scale=1
-                    )
-                    payment_filter = gr.Dropdown(
-                        choices=["all", "pending", "paid", "cod"],
-                        value="all",
-                        label="Payment",
-                        scale=1
-                    )
-                    search_orders = gr.Textbox(
-                        placeholder="Search by Order ID, Customer, Phone...",
-                        label="Search",
-                        scale=2
+                    search_box = gr.Textbox(
+                        placeholder="Search by Order ID or Customer Name...",
+                        label="Search Orders",
+                        scale=3
                     )
+                    search_btn = gr.Button("🔍 Search", scale=1)
+                    create_btn = gr.Button("➕ Create Sample Order", scale=1, variant="primary")
 
-                with gr.Row():
-                    apply_filters_btn = gr.Button("🔍 Apply Filters", variant="primary", scale=1)
-                    refresh_orders_btn = gr.Button("🔄 Refresh", scale=1)
+                create_result = gr.Textbox(label="Result", visible=False)
 
-                # Orders Table
                 orders_table = gr.Dataframe(
-                    headers=["Order ID", "Customer", "Address", "Status", "Priority", "Driver", "Deadline"],
-                    datatype=["str", "str", "str", "str", "str", "str", "str"],
-                    label="Orders List (Click row to view details)",
+                    headers=["Order ID", "Customer", "Delivery Address", "Status", "Priority", "Created At"],
+                    datatype=["str", "str", "str", "str", "str", "str"],
+                    label="Orders List",
                     value=get_all_orders(),
                     interactive=False,
                     wrap=True
                 )
 
-                # Order Details
-                gr.Markdown("---")
-                gr.Markdown("**Order Details:**")
-                order_details = gr.Markdown("*Select an order from the table above to view full details*")
-
-                # Edit/Delete Actions
-                gr.Markdown("---")
-                gr.Markdown("**Order Actions:**")
-
-                with gr.Row():
-                    selected_order_id_edit = gr.Textbox(label="Order ID to Edit", placeholder="ORD-XXXXXXXX", scale=2)
-                    edit_order_btn = gr.Button("✏️ Edit Order", variant="secondary", scale=1)
-                    delete_order_btn = gr.Button("🗑️ Delete Order", variant="stop", scale=1)
-
-                # Edit Form (in accordion)
-                with gr.Accordion("Edit Order Form", open=False) as edit_accordion:
-                    with gr.Row():
-                        edit_customer_name = gr.Textbox(label="Customer Name")
-                        edit_customer_phone = gr.Textbox(label="Customer Phone")
-                    with gr.Row():
-                        edit_status = gr.Dropdown(
-                            choices=["pending", "assigned", "in_transit", "delivered", "failed", "cancelled"],
-                            label="Status"
-                        )
-                        edit_priority = gr.Dropdown(
-                            choices=["standard", "express", "urgent"],
-                            label="Priority"
-                        )
-                    with gr.Row():
-                        edit_payment_status = gr.Dropdown(
-                            choices=["pending", "paid", "cod"],
-                            label="Payment Status"
-                        )
-                        edit_weight_kg = gr.Number(label="Weight (kg)")
-                    edit_special_instructions = gr.Textbox(label="Special Instructions", lines=2)
-
-                    save_order_btn = gr.Button("💾 Save Changes", variant="primary")
-
-                # Action Results
-                action_result = gr.Markdown("")
-
-                # Event handlers
-                def filter_and_update_orders(status, priority, payment, search):
-                    return get_all_orders(status, priority, payment, search)
-
-                def refresh_orders_and_stats(status, priority, payment, search):
-                    stats = update_order_stats()
-                    table = get_all_orders(status, priority, payment, search)
-                    return stats[0], stats[1], stats[2], stats[3], table
-
-                def show_order_details(evt: gr.SelectData, table_data):
-                    try:
-                        # table_data is a pandas DataFrame from Gradio
-                        if hasattr(table_data, 'iloc'):
-                            # DataFrame - use iloc to access row and column
-                            order_id = table_data.iloc[evt.index[0], 0]
-                        else:
-                            # List of lists - use standard indexing
-                            order_id = table_data[evt.index[0]][0]
-                        return get_order_details(order_id)
-                    except Exception as e:
-                        return f"Error: {str(e)}"
-
-                apply_filters_btn.click(
-                    fn=filter_and_update_orders,
-                    inputs=[status_filter, priority_filter, payment_filter, search_orders],
-                    outputs=orders_table
-                )
-
-                refresh_orders_btn.click(
-                    fn=refresh_orders_and_stats,
-                    inputs=[status_filter, priority_filter, payment_filter, search_orders],
-                    outputs=[stat_total, stat_pending, stat_transit, stat_delivered, orders_table]
-                )
-
-                orders_table.select(
-                    fn=show_order_details,
-                    inputs=[orders_table],
-                    outputs=order_details
+                refresh_orders_btn = gr.Button("🔄 Refresh Orders")
+
+                # Button actions
+                create_btn.click(
+                    fn=create_sample_order,
+                    outputs=[create_result, orders_table]
+                ).then(
+                    fn=lambda: gr.update(visible=True),
+                    outputs=create_result
+                ).then(
+                    fn=lambda: get_orders_summary(),
+                    outputs=orders_summary
                 )
 
-                # Edit/Delete handlers
-                def handle_edit_order(order_id):
-                    if not order_id:
-                        return "Please enter an Order ID"
-                    # Fetch order details and populate form
-                    query = "SELECT * FROM orders WHERE order_id = %s"
-                    from database.connection import execute_query
-                    results = execute_query(query, (order_id,))
-                    if not results:
-                        return "Order not found"
-                    order = results[0]
-                    return (
-                        order.get('customer_name', ''),
-                        order.get('customer_phone', ''),
-                        order.get('status', ''),
-                        order.get('priority', ''),
-                        order.get('payment_status', ''),
-                        order.get('weight_kg', 0),
-                        order.get('special_instructions', ''),
-                        "Order loaded. Update fields and click Save Changes."
-                    )
-
-                def handle_save_order(order_id, name, phone, status, priority, payment, weight, instructions, status_f, priority_f, payment_f, search):
-                    if not order_id:
-                        return "Please enter an Order ID", get_all_orders(status_f, priority_f, payment_f, search)
-
-                    fields = {}
-                    if name:
-                        fields['customer_name'] = name
-                    if phone:
-                        fields['customer_phone'] = phone
-                    if status:
-                        fields['status'] = status
-                    if priority:
-                        fields['priority'] = priority
-                    if payment:
-                        fields['payment_status'] = payment
-                    if weight:
-                        fields['weight_kg'] = float(weight)
-                    if instructions:
-                        fields['special_instructions'] = instructions
-
-                    result = update_order_ui(order_id, **fields)
-
-                    # Refresh table
-                    refreshed_table = get_all_orders(status_f, priority_f, payment_f, search)
-
-                    if result['success']:
-                        return f"✅ {result['message']}", refreshed_table
-                    else:
-                        return f"❌ {result.get('error', 'Update failed')}", refreshed_table
-
-                def handle_delete_order(order_id, status_f, priority_f, payment_f, search):
-                    if not order_id:
-                        return "Please enter an Order ID", get_all_orders(status_f, priority_f, payment_f, search)
-
-                    result = delete_order_ui(order_id)
-
-                    # Refresh table
-                    refreshed_table = get_all_orders(status_f, priority_f, payment_f, search)
-
-                    if result['success']:
-                        return f"✅ {result['message']}", refreshed_table
-                    else:
-                        return f"❌ {result.get('error', 'Deletion failed')}", refreshed_table
-
-                edit_order_btn.click(
-                    fn=handle_edit_order,
-                    inputs=[selected_order_id_edit],
-                    outputs=[edit_customer_name, edit_customer_phone, edit_status, edit_priority,
-                            edit_payment_status, edit_weight_kg, edit_special_instructions, action_result]
+                search_btn.click(
+                    fn=search_orders,
+                    inputs=search_box,
+                    outputs=orders_table
                 )
 
-                save_order_btn.click(
-                    fn=handle_save_order,
-                    inputs=[selected_order_id_edit, edit_customer_name, edit_customer_phone, edit_status,
-                           edit_priority, edit_payment_status, edit_weight_kg, edit_special_instructions,
-                           status_filter, priority_filter, payment_filter, search_orders],
-                    outputs=[action_result, orders_table]
+                search_box.submit(
+                    fn=search_orders,
+                    inputs=search_box,
+                    outputs=orders_table
                 )
 
-                delete_order_btn.click(
-                    fn=handle_delete_order,
-                    inputs=[selected_order_id_edit, status_filter, priority_filter, payment_filter, search_orders],
-                    outputs=[action_result, orders_table]
+                refresh_orders_btn.click(
+                    fn=get_all_orders,
+                    outputs=orders_table
+                ).then(
+                    fn=lambda: get_orders_summary(),
+                    outputs=orders_summary
                 )
 
             # ==========================================
-            # TAB 3: DRIVERS
+            # TAB 3: AI CHAT
             # ==========================================
-            with gr.Tab("👥 Drivers Management"):
-                gr.Markdown("### Drivers Dashboard")
-
-                # Statistics Cards
-                def update_driver_stats():
-                    stats = get_drivers_stats()
-                    return (
-                        f"**Total:** {stats['total']}",
-                        f"**Active:** {stats['active']}",
-                        f"**Busy:** {stats['busy']}",
-                        f"**Offline:** {stats['offline']}"
-                    )
+            with gr.Tab("💬 Chat"):
+                provider_name = chat_engine.get_provider_name()
+                model_name = chat_engine.get_model_name()
 
-                with gr.Row():
-                    driver_stat_total = gr.Markdown("**Total:** 0")
-                    driver_stat_active = gr.Markdown("**Active:** 0")
-                    driver_stat_busy = gr.Markdown("**Busy:** 0")
-                    driver_stat_offline = gr.Markdown("**Offline:** 0")
+                gr.Markdown(f"### AI Order Assistant")
+                gr.Markdown(f"*Powered by: **{provider_name}** ({model_name})*")
 
-                gr.Markdown("---")
+                # API Status
+                api_status = gr.Markdown(get_api_status())
 
-                # Filters
-                gr.Markdown("**Filters:**")
-                with gr.Row():
-                    driver_status_filter = gr.Dropdown(
-                        choices=["all", "active", "busy", "offline", "unavailable"],
-                        value="all",
-                        label="Status",
-                        scale=1
-                    )
-                    vehicle_filter = gr.Dropdown(
-                        choices=["all", "van", "truck", "car", "motorcycle"],
-                        value="all",
-                        label="Vehicle Type",
-                        scale=1
-                    )
-                    search_drivers = gr.Textbox(
-                        placeholder="Search by Driver ID, Name, Phone, Plate...",
-                        label="Search",
-                        scale=2
-                    )
-
-                with gr.Row():
-                    apply_driver_filters_btn = gr.Button("🔍 Apply Filters", variant="primary", scale=1)
-                    refresh_drivers_btn = gr.Button("🔄 Refresh", scale=1)
-
-                # Drivers Table
-                drivers_table = gr.Dataframe(
-                    headers=["Driver ID", "Name", "Phone", "Status", "Vehicle", "Location", "Last Update"],
-                    datatype=["str", "str", "str", "str", "str", "str", "str"],
-                    label="Drivers List (Click row to view details)",
-                    value=get_all_drivers(),
-                    interactive=False,
-                    wrap=True
+                # Chat interface
+                chatbot = gr.Chatbot(
+                    label="Order Assistant",
+                    height=500,
+                    type="messages",
+                    show_copy_button=True
                 )
 
-                # Driver Details
-                gr.Markdown("---")
-                gr.Markdown("**Driver Details:**")
-                driver_details = gr.Markdown("*Select a driver from the table above to view full details*")
-
-                # Edit/Delete Actions
-                gr.Markdown("---")
-                gr.Markdown("**Driver Actions:**")
+                msg_input = gr.Textbox(
+                    placeholder="e.g., 'Create an order for John Doe at 123 Main St, deliver by 5 PM'",
+                    label="Your Message",
+                    lines=2
+                )
 
                 with gr.Row():
-                    selected_driver_id_edit = gr.Textbox(label="Driver ID to Edit", placeholder="DRV-XXXXXXXX", scale=2)
-                    edit_driver_btn = gr.Button("✏️ Edit Driver", variant="secondary", scale=1)
-                    delete_driver_btn = gr.Button("🗑️ Delete Driver", variant="stop", scale=1)
-
-                # Edit Form (in accordion)
-                with gr.Accordion("Edit Driver Form", open=False) as driver_edit_accordion:
-                    with gr.Row():
-                        edit_driver_name = gr.Textbox(label="Driver Name")
-                        edit_driver_phone = gr.Textbox(label="Phone")
-                    with gr.Row():
-                        edit_driver_email = gr.Textbox(label="Email")
-                        edit_driver_status = gr.Dropdown(
-                            choices=["active", "busy", "offline", "unavailable"],
-                            label="Status"
-                        )
-                    with gr.Row():
-                        edit_vehicle_type = gr.Textbox(label="Vehicle Type")
-                        edit_vehicle_plate = gr.Textbox(label="Vehicle Plate")
-                    with gr.Row():
-                        edit_capacity_kg = gr.Number(label="Capacity (kg)")
-                        edit_capacity_m3 = gr.Number(label="Capacity (m³)")
+                    send_btn = gr.Button("📤 Send", variant="primary", scale=2)
+                    clear_btn = gr.Button("🔄 Clear Chat", scale=1)
+
+                # Tool usage display (reasoning transparency)
+                with gr.Accordion("🔧 Tool Usage (AI Reasoning)", open=False):
+                    gr.Markdown("See what tools the AI is using behind the scenes:")
+                    tool_display = gr.JSON(label="Tools Called")
 
-                    save_driver_btn = gr.Button("💾 Save Changes", variant="primary")
+                # Conversation state
+                conversation_state = gr.State(value=None)
 
-                # Action Results
-                driver_action_result = gr.Markdown("")
+                # Initialize with welcome message
+                chatbot.value, tool_display.value, conversation_state.value = get_initial_chat()
 
                 # Event handlers
-                def filter_and_update_drivers(status, vehicle, search):
-                    return get_all_drivers(status, vehicle, search)
-
-                def refresh_drivers_and_stats(status, vehicle, search):
-                    stats = update_driver_stats()
-                    table = get_all_drivers(status, vehicle, search)
-                    return stats[0], stats[1], stats[2], stats[3], table
-
-                def show_driver_details(evt: gr.SelectData, table_data):
-                    try:
-                        # table_data is a pandas DataFrame from Gradio
-                        if hasattr(table_data, 'iloc'):
-                            # DataFrame - use iloc to access row and column
-                            driver_id = table_data.iloc[evt.index[0], 0]
-                        else:
-                            # List of lists - use standard indexing
-                            driver_id = table_data[evt.index[0]][0]
-                        return get_driver_details(driver_id)
-                    except Exception as e:
-                        return f"Error: {str(e)}"
-
-                apply_driver_filters_btn.click(
-                    fn=filter_and_update_drivers,
-                    inputs=[driver_status_filter, vehicle_filter, search_drivers],
-                    outputs=drivers_table
-                )
+                def send_message(message, conv_state):
+                    """Handle send button click"""
+                    chat_history, tools, new_state = handle_chat_message(message, conv_state)
+                    return chat_history, tools, new_state, ""  # Clear input
 
-                refresh_drivers_btn.click(
-                    fn=refresh_drivers_and_stats,
-                    inputs=[driver_status_filter, vehicle_filter, search_drivers],
-                    outputs=[driver_stat_total, driver_stat_active, driver_stat_busy, driver_stat_offline, drivers_table]
+                send_btn.click(
+                    fn=send_message,
+                    inputs=[msg_input, conversation_state],
+                    outputs=[chatbot, tool_display, conversation_state, msg_input]
                 )
 
-                drivers_table.select(
-                    fn=show_driver_details,
-                    inputs=[drivers_table],
-                    outputs=driver_details
+                msg_input.submit(
+                    fn=send_message,
+                    inputs=[msg_input, conversation_state],
+                    outputs=[chatbot, tool_display, conversation_state, msg_input]
                 )
 
-                # Edit/Delete handlers
-                def handle_edit_driver(driver_id):
-                    if not driver_id:
-                        return "Please enter a Driver ID"
-                    # Fetch driver details and populate form
-                    query = "SELECT * FROM drivers WHERE driver_id = %s"
-                    from database.connection import execute_query
-                    results = execute_query(query, (driver_id,))
-                    if not results:
-                        return "Driver not found"
-                    driver = results[0]
-                    return (
-                        driver.get('name', ''),
-                        driver.get('phone', ''),
-                        driver.get('email', ''),
-                        driver.get('status', ''),
-                        driver.get('vehicle_type', ''),
-                        driver.get('vehicle_plate', ''),
-                        driver.get('capacity_kg', 0),
-                        driver.get('capacity_m3', 0),
-                        "Driver loaded. Update fields and click Save Changes."
-                    )
-
-                def handle_save_driver(driver_id, name, phone, email, status, vehicle_type, vehicle_plate, capacity_kg, capacity_m3, status_f, vehicle_f, search):
-                    if not driver_id:
-                        return "Please enter a Driver ID", get_all_drivers(status_f, vehicle_f, search)
-
-                    fields = {}
-                    if name:
-                        fields['name'] = name
-                    if phone:
-                        fields['phone'] = phone
-                    if email:
-                        fields['email'] = email
-                    if status:
-                        fields['status'] = status
-                    if vehicle_type:
-                        fields['vehicle_type'] = vehicle_type
-                    if vehicle_plate:
-                        fields['vehicle_plate'] = vehicle_plate
-                    if capacity_kg:
-                        fields['capacity_kg'] = float(capacity_kg)
-                    if capacity_m3:
-                        fields['capacity_m3'] = float(capacity_m3)
-
-                    result = update_driver_ui(driver_id, **fields)
-
-                    # Refresh table
-                    refreshed_table = get_all_drivers(status_f, vehicle_f, search)
-
-                    if result['success']:
-                        return f"✅ {result['message']}", refreshed_table
-                    else:
-                        return f"❌ {result.get('error', 'Update failed')}", refreshed_table
-
-                def handle_delete_driver(driver_id, status_f, vehicle_f, search):
-                    if not driver_id:
-                        return "Please enter a Driver ID", get_all_drivers(status_f, vehicle_f, search)
-
-                    result = delete_driver_ui(driver_id)
-
-                    # Refresh table
-                    refreshed_table = get_all_drivers(status_f, vehicle_f, search)
-
-                    if result['success']:
-                        return f"✅ {result['message']}", refreshed_table
-                    else:
-                        return f"❌ {result.get('error', 'Deletion failed')}", refreshed_table
-
-                edit_driver_btn.click(
-                    fn=handle_edit_driver,
-                    inputs=[selected_driver_id_edit],
-                    outputs=[edit_driver_name, edit_driver_phone, edit_driver_email, edit_driver_status,
-                            edit_vehicle_type, edit_vehicle_plate, edit_capacity_kg, edit_capacity_m3, driver_action_result]
+                clear_btn.click(
+                    fn=reset_conversation,
+                    outputs=[chatbot, tool_display, conversation_state]
                 )
 
-                save_driver_btn.click(
-                    fn=handle_save_driver,
-                    inputs=[selected_driver_id_edit, edit_driver_name, edit_driver_phone, edit_driver_email,
-                           edit_driver_status, edit_vehicle_type, edit_vehicle_plate, edit_capacity_kg, edit_capacity_m3,
-                           driver_status_filter, vehicle_filter, search_drivers],
-                    outputs=[driver_action_result, drivers_table]
-                )
+            # ==========================================
+            # TAB 4: MCP TOOLS (Coming Soon)
+            # ==========================================
+            with gr.Tab("🔧 MCP Tools"):
+                gr.Markdown("### MCP Tools")
+                gr.Markdown("*MCP tool integration coming soon...*")
+
+                gr.Markdown("""
+                Available tools:
+                - **route_optimizer** - Optimize delivery routes
+                - **geocoder** - Convert addresses to coordinates
+                - **weather_monitor** - Check weather conditions
+                - **traffic_checker** - Monitor traffic conditions
+                - **distance_matrix** - Calculate distances
+                - **order_manager** - Manage orders via MCP
+                """)
 
-                delete_driver_btn.click(
-                    fn=handle_delete_driver,
-                    inputs=[selected_driver_id_edit, driver_status_filter, vehicle_filter, search_drivers],
-                    outputs=[driver_action_result, drivers_table]
+            # ==========================================
+            # TAB 5: DATABASE INFO
+            # ==========================================
+            with gr.Tab("💾 Database"):
+                gr.Markdown("### Database Information")
+
+                db_info = gr.Markdown(f"""
+                **Database:** PostgreSQL
+                **Name:** fleetmind
+                **Host:** localhost
+                **Port:** 5432
+
+                **Tables:**
+                - orders (26 columns)
+                - drivers (coming soon)
+                - assignments (coming soon)
+                - exceptions (coming soon)
+                """)
+
+                test_db_btn = gr.Button("🧪 Test Connection", variant="primary")
+                test_result = gr.Textbox(label="Test Result", interactive=False)
+
+                test_db_btn.click(
+                    fn=lambda: "✅ Connection successful!" if test_connection() else "❌ Connection failed",
+                    outputs=test_result
                 )
 
         gr.Markdown("---")
-        gr.Markdown("*FleetMind v1.0 - AI-Powered Dispatch Coordination*")
-
-        # Initialize chat and stats on load
-        app.load(
-            fn=get_initial_chat,
-            outputs=[chatbot, tool_display, session_id_state]
-        ).then(
-            fn=update_order_stats,
-            outputs=[stat_total, stat_pending, stat_transit, stat_delivered]
-        ).then(
-            fn=update_driver_stats,
-            outputs=[driver_stat_total, driver_stat_active, driver_stat_busy, driver_stat_offline]
-        )
+        gr.Markdown("*FleetMind MCP v1.0.0 - Built with Gradio, PostgreSQL, and FastMCP*")
 
     return app
 
@@ -1105,23 +518,25 @@ def create_interface():
 
 if __name__ == "__main__":
     print("=" * 60)
-    print("FleetMind - Starting Enhanced UI")
+    print("FleetMind MCP - Starting Gradio Server")
     print("=" * 60)
 
+    # Check database connection
     print("\nChecking database connection...")
     if test_connection():
         print("✅ Database connected")
     else:
         print("❌ Database connection failed")
+        print("Please check your .env file and PostgreSQL server")
 
     print("\nStarting Gradio interface...")
     print("=" * 60)
 
+    # Create and launch the interface
     app = create_interface()
     app.launch(
-        server_name="0.0.0.0",
+        server_name="0.0.0.0",  # Allow external connections for HF Spaces
         server_port=7860,
         share=False,
-        show_error=True,
-        show_api=False
+        show_error=True
     )