Upload 2 files

app.py

@@ -5,8 +5,20 @@ import os
 import logging
 import requests
 import threading
-from queue import Queue
+from queue import Queue, PriorityQueue
 from functools import lru_cache
+import concurrent.futures
+import asyncio
+import aiohttp
+import hashlib
+import pickle
+import time
+import psutil
+from threading import Lock
+from dataclasses import dataclass
+from enum import Enum
+import heapq
+import json
 
 app = Flask(__name__)
 logging.basicConfig(level=logging.INFO)
@@ -14,14 +26,133 @@ logging.basicConfig(level=logging.INFO)
 CACHE_DIR = "/data"
 model_name = "Qwen/Qwen2.5-0.5B-Instruct"
 
-# Load model and tokenizer
-logging.info("Loading tokenizer...")
-tokenizer = AutoTokenizer.from_pretrained(model_name, cache_dir=CACHE_DIR, trust_remote_code=True)
-logging.info("Loading model...")
-model = AutoModelForCausalLM.from_pretrained(model_name, cache_dir=CACHE_DIR, trust_remote_code=True)
-logging.info("Creating pipeline...")
-generator = pipeline("text-generation", model=model, tokenizer=tokenizer, device=-1)
-logging.info("Model ready.")
+# Performance monitoring
+class PerformanceMonitor:
+    def __init__(self):
+        self.metrics = {
+            'request_count': 0,
+            'avg_response_time': 0,
+            'memory_usage': 0,
+            'cpu_usage': 0,
+            'cache_hits': 0,
+            'cache_misses': 0
+        }
+        self.lock = Lock()
+    
+    def track_request(self, start_time, end_time, cache_hit=False):
+        with self.lock:
+            response_time = end_time - start_time
+            self.metrics['request_count'] += 1
+            self.metrics['avg_response_time'] = (
+                (self.metrics['avg_response_time'] * (self.metrics['request_count'] - 1) + response_time) 
+                / self.metrics['request_count']
+            )
+            self.metrics['memory_usage'] = psutil.virtual_memory().percent
+            self.metrics['cpu_usage'] = psutil.cpu_percent()
+            if cache_hit:
+                self.metrics['cache_hits'] += 1
+            else:
+                self.metrics['cache_misses'] += 1
+
+# Advanced caching system
+class SmartCache:
+    def __init__(self, max_size=1000):
+        self.cache = {}
+        self.max_size = max_size
+        self.lock = Lock()
+        self.access_times = {}
+    
+    def cache_key(self, data):
+        """Generate cache key from data"""
+        return hashlib.md5(str(sorted(data.items())).encode()).hexdigest()
+    
+    def get(self, key):
+        """Get from cache with LRU eviction"""
+        with self.lock:
+            if key in self.cache:
+                self.access_times[key] = time.time()
+                return self.cache[key]
+            return None
+    
+    def set(self, key, value):
+        """Set cache with LRU eviction"""
+        with self.lock:
+            if len(self.cache) >= self.max_size and key not in self.cache:
+                # Remove least recently used item
+                lru_key = min(self.access_times.keys(), key=lambda k: self.access_times[k])
+                del self.cache[lru_key]
+                del self.access_times[lru_key]
+            
+            self.cache[key] = value
+            self.access_times[key] = time.time()
+
+# Model Manager with Thread Pool
+class ModelManager:
+    def __init__(self, model_name, max_workers=3):
+        self.model_name = model_name
+        self.model_pool = Queue(maxsize=max_workers)
+        self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=max_workers)
+        self._initialize_models(max_workers)
+    
+    def _initialize_models(self, max_workers):
+        """Pre-load multiple model instances"""
+        logging.info(f"Initializing {max_workers} model instances...")
+        for i in range(max_workers):
+            try:
+                tokenizer = AutoTokenizer.from_pretrained(self.model_name, cache_dir=CACHE_DIR, trust_remote_code=True)
+                model = AutoModelForCausalLM.from_pretrained(self.model_name, cache_dir=CACHE_DIR, trust_remote_code=True)
+                generator = pipeline("text-generation", model=model, tokenizer=tokenizer, device=-1)
+                self.model_pool.put(generator)
+                logging.info(f"Model instance {i+1} loaded successfully")
+            except Exception as e:
+                logging.error(f"Failed to load model instance {i+1}: {e}")
+    
+    def generate_async(self, prompt, max_new_tokens=200, temperature=0.5):
+        """Submit generation task to thread pool"""
+        def _generate_with_model():
+            try:
+                generator = self.model_pool.get()
+                result = generator(prompt, max_new_tokens=max_new_tokens, temperature=temperature)[0]['generated_text']
+                self.model_pool.put(generator)  # Return model to pool
+                return result
+            except Exception as e:
+                logging.error(f"Model generation error: {e}")
+                return f"Error: {e}"
+        
+        return self.executor.submit(_generate_with_model)
+    
+    def warmup_models(self):
+        """Warm up models with sample prompts"""
+        sample_prompts = [
+            "Generate a property description for a residential apartment",
+            "Generate a property description for a commercial office space",
+            "Generate a property description for agricultural land"
+        ]
+        
+        futures = []
+        for prompt in sample_prompts:
+            future = self.generate_async(prompt, max_new_tokens=50)
+            futures.append(future)
+        
+        # Wait for warmup to complete
+        for future in futures:
+            try:
+                future.result(timeout=30)
+            except Exception as e:
+                logging.warning(f"Warmup failed: {e}")
+        
+        logging.info("Model warmup completed")
+
+# Initialize components
+performance_monitor = PerformanceMonitor()
+cache = SmartCache()
+model_manager = ModelManager(model_name)
+
+# Warmup models in background
+warmup_thread = threading.Thread(target=model_manager.warmup_models, daemon=True)
+warmup_thread.start()
+
+logging.info("Enhanced system initialized.")
 
 # Fallback description text
 def get_fallback_description(details):
@@ -35,81 +166,135 @@ def get_fallback_description(details):
     nearby_info = ""
     lat = details.get('latitude')
     lon = details.get('longitude')
-    if lat and lon:
-        try:
-            lat_f, lon_f = float(lat), float(lon)
-            result_queue = Queue()
-            thread = threading.Thread(target=fetch_nearby_amenities_thread, args=(lat_f, lon_f, 2500, result_queue))
-            thread.start()
-            thread.join(timeout=8)
-            landmarks = result_queue.get() if not result_queue.empty() else []
-            
-            if landmarks:
-                amenities = [x for x in landmarks if any(term in x.lower() for term in ['school', 'hospital', 'restaurant', 'pharmacy', 'bank', 'atm', 'cafe', 'bus', 'fuel', 'supermarket', 'police', 'post'])]
-                landmarks = [x for x in landmarks if x not in amenities]
+        if lat and lon:
+            try:
+                lat_f, lon_f = float(lat), float(lon)
+                landmarks = amenity_fetcher.fetch_amenities_parallel(lat_f, lon_f, 2500)
                 
-                if amenities:
-                    nearby_info += f" The property is conveniently located near {', '.join(amenities[:2])}."
                 if landmarks:
-                    nearby_info += f" Notable landmarks include {', '.join(landmarks[:2])}."
-        except Exception as e:
-            logging.error(f"Fallback amenity fetch error: {str(e)}")
-            pass
+                    amenities = [x for x in landmarks if any(term in x.lower() for term in ['school', 'hospital', 'restaurant', 'pharmacy', 'bank', 'atm', 'cafe', 'bus', 'fuel', 'supermarket', 'police', 'post'])]
+                    landmarks = [x for x in landmarks if x not in amenities]
+                    
+                    if amenities:
+                        nearby_info += f" The property is conveniently located near {', '.join(amenities[:2])}."
+                    if landmarks:
+                        nearby_info += f" Notable landmarks include {', '.join(landmarks[:2])}."
+            except Exception as e:
+                logging.error(f"Fallback amenity fetch error: {str(e)}")
+                pass
     
     if category in ['agricultural', 'commercial']:
         return f'''A prime agricultural property located at {address}. This expansive land spans {area} sq. ft., making it ideal for farming or agricultural development. The property is priced at ₹{price} and features {rooms} storage/utility rooms. The land is well-irrigated and offers excellent soil quality, perfect for various agricultural activities.{nearby_info} Whether you're looking to start a farm or expand your agricultural operations, this property provides the perfect foundation for your agricultural ventures.'''
     else:  # Commercial
         return f'''A premium commercial property situated in the heart of {address}. This modern commercial space spans {area} sq. ft., offering a versatile layout with {rooms} rooms for optimal business operations. Priced at ₹{price}, this property features excellent visibility and accessibility.{nearby_info} The space is designed to accommodate various business needs, from retail to office use, with modern amenities and professional atmosphere. Whether you're establishing a new business or expanding existing operations, this location provides the perfect blend of convenience and functionality.'''
 
-@lru_cache(maxsize=100)
-def fetch_nearby_amenities_thread(lat, lon, radius, result_queue):
-    try:
-        overpass_url = "https://overpass-api.de/api/interpreter"
-        query = f"""
-        [out:json][timeout:10];
-        (
-          node["amenity"~"school|hospital|restaurant|temple|mandir|hotel|pharmacy|bank|atm|cafe|bus_station|fuel|supermarket|police|post_office"](around:{radius},{lat},{lon});
-          node["tourism"~"hotel|museum|gallery|viewpoint|attraction"](around:{radius},{lat},{lon});
-          node["historic"~"monument|memorial|archaeological_site|castle|ruins"](around:{radius},{lat},{lon});
-          node["leisure"~"park|garden|sports_centre|stadium"](around:{radius},{lat},{lon});
-        );
-        out body;
-        """
-        response = requests.post(overpass_url, data={'data': query}, timeout=10)
-        response.raise_for_status()
-        data = response.json()
-        landmarks = []
-        seen_names = set()
+# Enhanced Parallel Amenity Fetcher
+class ParallelAmenityFetcher:
+    def __init__(self, max_workers=5):
+        self.executor = concurrent.futures.ThreadPoolExecutor(max_workers=max_workers)
+        self.cache = {}
+        self.cache_lock = Lock()
+    
+    def fetch_amenities_parallel(self, lat, lon, radius=2000):
+        """Fetch amenities using parallel requests with caching"""
+        cache_key = f"{lat}_{lon}_{radius}"
+        
+        # Check cache first
+        with self.cache_lock:
+            if cache_key in self.cache:
+                return self.cache[cache_key]
+        
+        # Create multiple parallel requests for different amenity types
+        amenity_types = [
+            "school|hospital",
+            "restaurant|pharmacy|bank|atm",
+            "tourism|historic|leisure",
+            "fuel|supermarket|police|post_office",
+            "temple|mandir|hotel|cafe|bus_station"
+        ]
+        
+        futures = []
+        for amenity_type in amenity_types:
+            future = self.executor.submit(self._fetch_amenity_type, lat, lon, radius, amenity_type)
+            futures.append(future)
         
-        for element in data.get('elements', []):
-            tags = element.get('tags', {})
-            name = tags.get('name')
-            if not name or name in seen_names:
-                continue
-            seen_names.add(name)
+        # Collect results
+        all_amenities = []
+        for future in futures:
+            try:
+                result = future.result(timeout=8)
+                if result:
+                    all_amenities.extend(result)
+            except Exception as e:
+                logging.error(f"Amenity fetch error: {e}")
+        
+        # Cache result
+        with self.cache_lock:
+            self.cache[cache_key] = all_amenities
+        
+        return all_amenities
+    
+    def _fetch_amenity_type(self, lat, lon, radius, amenity_type):
+        """Fetch specific amenity type"""
+        try:
+            overpass_url = "https://overpass-api.de/api/interpreter"
+            query = f"""
+            [out:json][timeout:8];
+            (
+              node["amenity"~"{amenity_type}"](around:{radius},{lat},{lon});
+              node["tourism"~"{amenity_type}"](around:{radius},{lat},{lon});
+              node["historic"~"{amenity_type}"](around:{radius},{lat},{lon});
+              node["leisure"~"{amenity_type}"](around:{radius},{lat},{lon});
+            );
+            out body;
+            """
+            response = requests.post(overpass_url, data={'data': query}, timeout=8)
+            response.raise_for_status()
+            data = response.json()
+            landmarks = []
+            seen_names = set()
             
-            place_type = None
-            if tags.get('tourism'):
-                place_type = tags['tourism'].replace('_', ' ').title()
-            elif tags.get('historic'):
-                place_type = tags['historic'].replace('_', ' ').title()
-            elif tags.get('leisure'):
-                place_type = tags['leisure'].replace('_', ' ').title()
-            elif tags.get('amenity'):
-                place_type = tags['amenity'].replace('_', ' ').title()
+            for element in data.get('elements', []):
+                tags = element.get('tags', {})
+                name = tags.get('name')
+                if not name or name in seen_names:
+                    continue
+                seen_names.add(name)
                 
-            if place_type:
-                landmarks.append((f"{place_type} '{name}'", len(name)))
-        
-        # Sort by name length and take top results
-        landmarks.sort(key=lambda x: x[1], reverse=True)
-        result_queue.put([x[0] for x in landmarks])
-    except Exception as e:
-        logging.error(f"Overpass API error: {str(e)}")
-        result_queue.put([])
+                place_type = None
+                if tags.get('tourism'):
+                    place_type = tags['tourism'].replace('_', ' ').title()
+                elif tags.get('historic'):
+                    place_type = tags['historic'].replace('_', ' ').title()
+                elif tags.get('leisure'):
+                    place_type = tags['leisure'].replace('_', ' ').title()
+                elif tags.get('amenity'):
+                    place_type = tags['amenity'].replace('_', ' ').title()
+                    
+                if place_type:
+                    landmarks.append((f"{place_type} '{name}'", len(name)))
+            
+            # Sort by name length and take top results
+            landmarks.sort(key=lambda x: x[1], reverse=True)
+            return [x[0] for x in landmarks]
+        except Exception as e:
+            logging.error(f"Overpass API error for {amenity_type}: {str(e)}")
+            return []
+
+# Initialize amenity fetcher
+amenity_fetcher = ParallelAmenityFetcher()
 
 def generate_description(details):
+    start_time = time.time()
+    
     try:
+        # Check cache first
+        cache_key = cache.cache_key(details)
+        cached_result = cache.get(cache_key)
+        if cached_result:
+            performance_monitor.track_request(start_time, time.time(), cache_hit=True)
+            return cached_result
+        
         category = details.get('parent_category', '').lower()
         
         # Basic info - only include beds/rooms for residential properties
@@ -128,19 +313,16 @@ def generate_description(details):
                 if baths: parts.append(bath_info)
                 extra_info = "This property includes " + " and ".join(parts) + "."
 
-        # Amenities thread with shorter timeout
+        # Parallel amenity fetching
         amenities_str = "None found nearby"
         landmarks_str = "None found nearby"
         lat = details.get('latitude')
         lon = details.get('longitude')
+        
         if lat and lon:
             try:
                 lat_f, lon_f = float(lat), float(lon)
-                result_queue = Queue()
-                thread = threading.Thread(target=fetch_nearby_amenities_thread, args=(lat_f, lon_f, 2000, result_queue))
-                thread.start()
-                thread.join(timeout=8)
-                landmarks = result_queue.get() if not result_queue.empty() else []
+                landmarks = amenity_fetcher.fetch_amenities_parallel(lat_f, lon_f, 2000)
                 
                 # Split into amenities and landmarks
                 amenities = [x for x in landmarks if any(term in x.lower() for term in ['school', 'hospital', 'restaurant', 'pharmacy', 'bank', 'atm', 'cafe', 'bus', 'fuel', 'supermarket', 'police', 'post'])]
@@ -181,34 +363,36 @@ def generate_description(details):
             prompt += f"\n\n{extra_info}"
         prompt += "\nWrite a natural, complete property description focusing on urban and property characteristics only.\nDescription:"
 
-        # Run generation in thread with longer timeout
-        result_queue = Queue()
-        def run_generation(q):
-            try:
-                out = generator(prompt, max_new_tokens=200, temperature=0.5)[0]['generated_text']
-                q.put(out)
-            except Exception as e:
-                q.put(f"Error: {e}")
-
-        gen_thread = threading.Thread(target=run_generation, args=(result_queue,))
-        gen_thread.start()
-        gen_thread.join(timeout=45)  # Increased timeout to 45 seconds
-
-        # Return dynamic fallback if generation takes too long or fails
-        if result_queue.empty():
+        # Use model manager for async generation
+        try:
+            future = model_manager.generate_async(prompt, max_new_tokens=200, temperature=0.5)
+            result = future.result(timeout=30)  # Reduced timeout to 30 seconds
+            
+            if result.startswith("Error:"):
+                logging.warning(f"Generation error - using fallback description: {result}")
+                result = get_fallback_description(details)
+            else:
+                result = result.split('Description:')[-1].strip() if 'Description:' in result else result.strip()
+                
+        except concurrent.futures.TimeoutError:
             logging.warning("Generation timeout - using fallback description")
-            return get_fallback_description(details)
-
-        result = result_queue.get()
-        if result.startswith("Error:"):
-            logging.warning(f"Generation error - using fallback description: {result}")
-            return get_fallback_description(details)
-
-        return result.split('Description:')[-1].strip() if 'Description:' in result else result.strip()
+            result = get_fallback_description(details)
+        except Exception as e:
+            logging.error(f"Generation error: {str(e)}")
+            result = get_fallback_description(details)
+        
+        # Cache the result
+        cache.set(cache_key, result)
+        
+        # Track performance
+        performance_monitor.track_request(start_time, time.time(), cache_hit=False)
+        
+        return result
 
     except Exception as e:
         logging.error(f"Generation error: {str(e)}")
-        return FALLBACK_DESCRIPTION
+        performance_monitor.track_request(start_time, time.time(), cache_hit=False)
+        return get_fallback_description(details)
 
 @app.route('/', methods=['GET', 'POST'])
 def index():
@@ -258,6 +442,106 @@ def generate():
     
     return {"description": desc + extra_info}
 
+@app.route('/generate_batch', methods=['POST'])
+def generate_batch():
+    """Generate descriptions for multiple properties in parallel"""
+    if not request.is_json:
+        return {"error": "Request must be JSON"}, 400
+    
+    data = request.get_json()
+    properties = data.get('properties', [])
+    
+    if not properties:
+        return {"error": "No properties provided"}, 400
+    
+    if len(properties) > 10:
+        return {"error": "Maximum 10 properties allowed per batch"}, 400
+    
+    # Validate all properties
+    for i, prop in enumerate(properties):
+        if not prop.get('property_name'):
+            return {"error": f"Property {i+1} missing required field: property_name"}, 400
+    
+    # Generate descriptions in parallel
+    with concurrent.futures.ThreadPoolExecutor(max_workers=min(len(properties), 5)) as executor:
+        futures = {executor.submit(generate_description, prop): prop for prop in properties}
+        results = []
+        
+        for future in concurrent.futures.as_completed(futures):
+            prop = futures[future]
+            try:
+                desc = future.result()
+                category = prop.get('parent_category', '').lower()
+                
+                # Add extra info based on category
+                if category not in ['agricultural', 'commercial']:
+                    info_lines = []
+                    beds = prop.get('beds', '')
+                    rooms = prop.get('total_rooms', '')
+                    baths = prop.get('baths', '')
+                    if beds and beds != '0':
+                        info_lines.append(f"Beds: {beds}")
+                    if rooms and rooms != '0':
+                        info_lines.append(f"Rooms: {rooms}")
+                    if baths and baths != '0':
+                        info_lines.append(f"Baths: {baths}")
+                    info_lines.append(f"Year: {prop.get('year', '')}")
+                    info_lines.append(f"Price: ₹{prop.get('price', '')}")
+                    extra_info = "\n" + "\n".join(info_lines)
+                else:
+                    extra_info = f"\nYear: {prop.get('year', '')}\nPrice: ₹{prop.get('price', '')}"
+                
+                results.append({
+                    "property_name": prop.get('property_name'),
+                    "description": desc + extra_info
+                })
+            except Exception as e:
+                results.append({
+                    "property_name": prop.get('property_name'),
+                    "error": str(e)
+                })
+    
+    return {"results": results}
+
+@app.route('/metrics', methods=['GET'])
+def get_metrics():
+    """Get performance metrics"""
+    with performance_monitor.lock:
+        metrics = performance_monitor.metrics.copy()
+    
+    # Add cache statistics
+    with cache.lock:
+        metrics['cache_size'] = len(cache.cache)
+        metrics['cache_max_size'] = cache.max_size
+    
+    # Add system metrics
+    metrics['system_memory_percent'] = psutil.virtual_memory().percent
+    metrics['system_cpu_percent'] = psutil.cpu_percent()
+    
+    return jsonify(metrics)
+
+@app.route('/health', methods=['GET'])
+def health_check():
+    """Health check endpoint"""
+    try:
+        # Test model availability
+        test_prompt = "Test prompt"
+        future = model_manager.generate_async(test_prompt, max_new_tokens=10)
+        future.result(timeout=5)
+        
+        return {
+            "status": "healthy",
+            "timestamp": time.time(),
+            "model_ready": True,
+            "cache_ready": True
+        }
+    except Exception as e:
+        return {
+            "status": "unhealthy",
+            "timestamp": time.time(),
+            "error": str(e)
+        }, 500
+
 if __name__ == '__main__':
     port = int(os.environ.get('PORT', 7860))
     logging.info(f"Starting app on port {port}")

templates/index.html

@@ -216,6 +216,7 @@
             </div>
 
             <button type="button" id="generate-btn">Generate Description</button>
+            <button type="button" id="batch-btn" style="background-color: #27ae60; margin-top: 10px;">Generate Batch (Demo)</button>
         </form>
         <div id="loading" style="display:none; color:#2980b9; margin-top:10px;">Generating description...</div>
         <div id="error" style="display:none; color:red; margin-top:10px;"></div>
@@ -223,6 +224,14 @@
             <h3>Generated Description:</h3>
             <p id="description-text"></p>
         </div>
+        <div id="batch-container" style="display:none; margin-top:20px;">
+            <h3>Batch Generation Results:</h3>
+            <div id="batch-results"></div>
+        </div>
+        <div id="metrics-container" style="display:none; margin-top:20px; padding:15px; background-color:#f8f9fa; border-radius:4px;">
+            <h3>Performance Metrics:</h3>
+            <div id="metrics-content"></div>
+        </div>
         <script>
         document.getElementById('generate-btn').addEventListener('click', async function() {
             const form = document.querySelector('form');
@@ -232,6 +241,7 @@
             document.getElementById('loading').style.display = 'block';
             document.getElementById('error').style.display = 'none';
             document.getElementById('description-container').style.display = 'none';
+            document.getElementById('batch-container').style.display = 'none';
             try {
                 const response = await fetch('/generate', {
                     method: 'POST',
@@ -253,6 +263,92 @@
                 document.getElementById('error').style.display = 'block';
             }
         });
+
+        document.getElementById('batch-btn').addEventListener('click', async function() {
+            const form = document.querySelector('form');
+            const formData = new FormData(form);
+            const baseData = {};
+            formData.forEach((value, key) => { baseData[key] = value; });
+            
+            // Create sample batch data
+            const batchData = {
+                properties: [
+                    { ...baseData, property_name: baseData.property_name + ' - Unit A' },
+                    { ...baseData, property_name: baseData.property_name + ' - Unit B' },
+                    { ...baseData, property_name: baseData.property_name + ' - Unit C' }
+                ]
+            };
+            
+            document.getElementById('loading').style.display = 'block';
+            document.getElementById('error').style.display = 'none';
+            document.getElementById('description-container').style.display = 'none';
+            document.getElementById('batch-container').style.display = 'none';
+            
+            try {
+                const response = await fetch('/generate_batch', {
+                    method: 'POST',
+                    headers: { 'Content-Type': 'application/json' },
+                    body: JSON.stringify(batchData)
+                });
+                const result = await response.json();
+                document.getElementById('loading').style.display = 'none';
+                
+                if (response.ok && result.results) {
+                    const resultsDiv = document.getElementById('batch-results');
+                    resultsDiv.innerHTML = '';
+                    
+                    result.results.forEach((item, index) => {
+                        const itemDiv = document.createElement('div');
+                        itemDiv.style.marginBottom = '20px';
+                        itemDiv.style.padding = '15px';
+                        itemDiv.style.border = '1px solid #ddd';
+                        itemDiv.style.borderRadius = '4px';
+                        itemDiv.style.backgroundColor = '#f9f9f9';
+                        
+                        if (item.error) {
+                            itemDiv.innerHTML = `<h4>${item.property_name}</h4><p style="color: red;">Error: ${item.error}</p>`;
+                        } else {
+                            itemDiv.innerHTML = `<h4>${item.property_name}</h4><p>${item.description}</p>`;
+                        }
+                        
+                        resultsDiv.appendChild(itemDiv);
+                    });
+                    
+                    document.getElementById('batch-container').style.display = 'block';
+                } else {
+                    document.getElementById('error').textContent = result.error || 'Failed to generate batch descriptions.';
+                    document.getElementById('error').style.display = 'block';
+                }
+            } catch (e) {
+                document.getElementById('loading').style.display = 'none';
+                document.getElementById('error').textContent = 'An error occurred during batch generation.';
+                document.getElementById('error').style.display = 'block';
+            }
+        });
+
+        // Load metrics on page load
+        async function loadMetrics() {
+            try {
+                const response = await fetch('/metrics');
+                const metrics = await response.json();
+                
+                const metricsContent = document.getElementById('metrics-content');
+                metricsContent.innerHTML = `
+                    <p><strong>Total Requests:</strong> ${metrics.request_count || 0}</p>
+                    <p><strong>Average Response Time:</strong> ${(metrics.avg_response_time || 0).toFixed(2)}s</p>
+                    <p><strong>Cache Hit Rate:</strong> ${metrics.cache_hits || 0}/${(metrics.cache_hits || 0) + (metrics.cache_misses || 0)}</p>
+                    <p><strong>Cache Size:</strong> ${metrics.cache_size || 0}/${metrics.cache_max_size || 0}</p>
+                    <p><strong>Memory Usage:</strong> ${(metrics.system_memory_percent || 0).toFixed(1)}%</p>
+                    <p><strong>CPU Usage:</strong> ${(metrics.system_cpu_percent || 0).toFixed(1)}%</p>
+                `;
+                document.getElementById('metrics-container').style.display = 'block';
+            } catch (e) {
+                console.log('Could not load metrics:', e);
+            }
+        }
+
+        // Load metrics when page loads
+        window.addEventListener('load', loadMetrics);
         </script>
     </div>
 </body>