Add 5-key Gemini API fallback, conversation memory, historical trends, and zone recommendations

app.py

@@ -36,13 +36,35 @@ logging.basicConfig(
 logger = logging.getLogger("ChatbotService")
 
 # ============================================================================
-# GEMINI SETUP - Using REST API directly
+# GEMINI SETUP - Multi-API Key Fallback System
 # ============================================================================
-GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
+
+# Load multiple API keys (GEMINI_API_KEY_1 through GEMINI_API_KEY_5)
+def load_gemini_api_keys() -> List[str]:
+    """Load all available Gemini API keys from environment."""
+    keys = []
+    
+    # Primary key
+    primary = os.environ.get("GEMINI_API_KEY")
+    if primary:
+        keys.append(primary)
+    
+    # Fallback keys 1-5
+    for i in range(1, 6):
+        key = os.environ.get(f"GEMINI_API_KEY_{i}")
+        if key and key not in keys:
+            keys.append(key)
+    
+    return keys
+
+GEMINI_API_KEYS = load_gemini_api_keys()
+current_key_index = 0  # Track which key is currently in use
+
+logger.info(f"Loaded {len(GEMINI_API_KEYS)} Gemini API key(s)")
 
 # Try to discover available models at startup
-def get_available_model():
-    """Try to find an available Gemini model."""
+def get_available_model(api_key: str):
+    """Try to find an available Gemini model with given API key."""
     models_to_try = [
         "gemini-2.0-flash",
         "gemini-1.5-flash", 
@@ -51,7 +73,7 @@ def get_available_model():
         "gemini-1.0-pro",
     ]
     
-    if not GEMINI_API_KEY:
+    if not api_key:
         return None, None
     
     for model in models_to_try:
@@ -59,7 +81,7 @@ def get_available_model():
             url = f"https://generativelanguage.googleapis.com/{version}/models/{model}:generateContent"
             try:
                 resp = requests.post(
-                    f"{url}?key={GEMINI_API_KEY}",
+                    f"{url}?key={api_key}",
                     json={"contents": [{"parts": [{"text": "test"}]}]},
                     timeout=10
                 )
@@ -71,81 +93,169 @@ def get_available_model():
     
     return None, None
 
-GEMINI_URL, GEMINI_MODEL = get_available_model()
+# Initialize with first available key
+GEMINI_URL, GEMINI_MODEL = None, None
+if GEMINI_API_KEYS:
+    GEMINI_URL, GEMINI_MODEL = get_available_model(GEMINI_API_KEYS[0])
+
 if GEMINI_URL:
     logger.info(f"Using Gemini model: {GEMINI_MODEL}")
 else:
-    GEMINI_URL = "https://generativelanguage.googleapis.com/v1beta/models/gemini-pro:generateContent"
-    logger.warning("Could not discover model, using default gemini-pro")
+    GEMINI_URL = "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent"
+    logger.warning("Could not discover model, using default gemini-2.0-flash")
 
-if GEMINI_API_KEY:
-    logger.info("Gemini API key configured successfully")
+if GEMINI_API_KEYS:
+    logger.info(f"Gemini API configured with {len(GEMINI_API_KEYS)} fallback key(s)")
 else:
-    logger.warning("GEMINI_API_KEY not set - chatbot will return mock responses")
+    logger.warning("No GEMINI_API_KEY set - chatbot will return mock responses")
 
 # Supabase client
 supabase = SupabaseClient()
 
 # ============================================================================
-# LLM CALLER
+# LLM CALLER WITH FALLBACK
 # ============================================================================
+def get_next_api_key() -> Optional[str]:
+    """Rotate to the next available API key."""
+    global current_key_index
+    if not GEMINI_API_KEYS:
+        return None
+    current_key_index = (current_key_index + 1) % len(GEMINI_API_KEYS)
+    logger.info(f"Rotated to API key {current_key_index + 1}/{len(GEMINI_API_KEYS)}")
+    return GEMINI_API_KEYS[current_key_index]
+
+
 def call_gemini_api(prompt: str) -> str:
-    """Call Gemini API directly using REST with retry logic."""
-    if not GEMINI_API_KEY:
-        return "Please configure GEMINI_API_KEY for real responses."
+    """
+    Call Gemini API with fallback across multiple API keys.
     
-    url = f"{GEMINI_URL}?key={GEMINI_API_KEY}"
+    Automatically rotates to next key on:
+    - 429 (rate limit)
+    - 403 (quota exceeded)
+    - 500+ (server errors)
+    """
+    global current_key_index
     
-    max_retries = 3
-    retry_delay = 2
+    if not GEMINI_API_KEYS:
+        return "Please configure GEMINI_API_KEY for real responses."
     
-    for attempt in range(max_retries):
-        try:
-            response = requests.post(
-                url,
-                headers={"Content-Type": "application/json"},
-                json={
-                    "contents": [{
-                        "parts": [{"text": prompt}]
-                    }],
-                    "generationConfig": {
-                        "temperature": 0.7,
-                        "maxOutputTokens": 2048,
-                    }
-                },
-                timeout=60
-            )
-            
-            if response.status_code == 200:
-                data = response.json()
-                if "candidates" in data and len(data["candidates"]) > 0:
-                    return data["candidates"][0]["content"]["parts"][0]["text"]
-                return "No response generated."
-            elif response.status_code == 429:
-                if attempt < max_retries - 1:
-                    import time
-                    wait_time = retry_delay * (2 ** attempt)
-                    logger.warning(f"Rate limited, waiting {wait_time}s...")
-                    time.sleep(wait_time)
-                    continue
-                return "I'm currently busy. Please try again in a moment."
-            else:
-                logger.error(f"Gemini API error: {response.status_code}")
-                return f"API error: {response.status_code}"
+    max_retries_per_key = 2
+    keys_tried = 0
+    
+    while keys_tried < len(GEMINI_API_KEYS):
+        current_key = GEMINI_API_KEYS[current_key_index]
+        url = f"{GEMINI_URL}?key={current_key}"
+        
+        for attempt in range(max_retries_per_key):
+            try:
+                response = requests.post(
+                    url,
+                    headers={"Content-Type": "application/json"},
+                    json={
+                        "contents": [{"parts": [{"text": prompt}]}],
+                        "generationConfig": {
+                            "temperature": 0.7,
+                            "maxOutputTokens": 2048,
+                        }
+                    },
+                    timeout=60
+                )
+                
+                if response.status_code == 200:
+                    data = response.json()
+                    if "candidates" in data and len(data["candidates"]) > 0:
+                        return data["candidates"][0]["content"]["parts"][0]["text"]
+                    return "No response generated."
                 
-        except Exception as e:
-            logger.error(f"Gemini request error: {e}")
-            if attempt < max_retries - 1:
+                elif response.status_code in [429, 403, 500, 502, 503]:
+                    # Rate limit, quota exceeded, or server error - try next key
+                    logger.warning(f"API key {current_key_index + 1} got {response.status_code}, rotating...")
+                    get_next_api_key()
+                    keys_tried += 1
+                    break  # Exit retry loop, try next key
+                    
+                else:
+                    logger.error(f"Gemini API error: {response.status_code}")
+                    return f"API error: {response.status_code}"
+                    
+            except requests.exceptions.Timeout:
+                logger.warning(f"Timeout on key {current_key_index + 1}, attempt {attempt + 1}")
+                if attempt == max_retries_per_key - 1:
+                    get_next_api_key()
+                    keys_tried += 1
+                continue
+                
+            except Exception as e:
+                logger.error(f"Gemini request error: {e}")
+                if attempt == max_retries_per_key - 1:
+                    get_next_api_key()
+                    keys_tried += 1
                 continue
-            return f"Error: {str(e)}"
     
-    return "Failed after retries. Please try again."
+    return "All API keys exhausted. Please try again later."
 
 
 # Initialize reasoning engine
 reasoning_engine = ReasoningEngine(llm_caller=call_gemini_api)
 intent_classifier = IntentClassifier()
 
+# Session history for conversation memory (follow-up awareness)
+# In production, this should be stored in Supabase/Redis, but for now use in-memory
+session_history: Dict[str, List[Dict]] = {}
+MAX_HISTORY_TURNS = 5
+
+
+def get_session_history(session_id: str) -> List[Dict]:
+    """Get recent conversation history for a session."""
+    return session_history.get(session_id, [])[-MAX_HISTORY_TURNS:]
+
+
+def add_to_session_history(session_id: str, role: str, content: str, 
+                           intent: str = None, diagnosis: str = None):
+    """Add a turn to session history for follow-up awareness."""
+    if session_id not in session_history:
+        session_history[session_id] = []
+    
+    turn = {
+        "role": role,
+        "content": content[:500],  # Truncate long content
+        "intent": intent,
+        "diagnosis": diagnosis[:200] if diagnosis else None
+    }
+    session_history[session_id].append(turn)
+    
+    # Keep only last N turns
+    if len(session_history[session_id]) > MAX_HISTORY_TURNS * 2:
+        session_history[session_id] = session_history[session_id][-MAX_HISTORY_TURNS:]
+
+
+def build_field_coordinates(field_data: Dict) -> Optional[Dict]:
+    """Build coordinates dict from field data with lat/lon corners."""
+    if not field_data:
+        return None
+    
+    lats = []
+    lons = []
+    for i in range(1, 5):
+        lat = field_data.get(f"lat{i}")
+        lon = field_data.get(f"lon{i}")
+        if lat is not None and lon is not None:
+            lats.append(float(lat))
+            lons.append(float(lon))
+    
+    if not lats or not lons:
+        return None
+    
+    center_lat = sum(lats) / len(lats)
+    center_lon = sum(lons) / len(lons)
+    
+    return {
+        "center_lat": round(center_lat, 6),
+        "center_lon": round(center_lon, 6),
+        "bbox": [min(lons), min(lats), max(lons), max(lats)]
+    }
+
+
 # ============================================================================
 # FASTAPI
 # ============================================================================
@@ -298,15 +408,77 @@ async def chat(request: ChatRequest):
             user_profile = supabase.get_user_profile(request.user_id)
             if user_profile:
                 context["user_profile"] = user_profile
+            
+            # Get all user fields for comparison detection
+            all_user_fields = supabase.get_user_fields(request.user_id)
+            field_names = [f.get("name", "") for f in all_user_fields if f.get("name")]
+        else:
+            user_profile = None
+            all_user_fields = []
+            field_names = []
+        
+        # Create persona from user profile for tailored responses
+        from prompts import create_user_persona, format_weather_context, format_zone_context, format_trend_context, format_conversation_history
+        persona = create_user_persona(user_profile, all_user_fields)
+        context["persona"] = persona
+        logger.info(f"User persona: {persona.get('type')}")
+        
+        # Get conversation history for follow-up awareness
+        conv_history = get_session_history(request.session_id)
+        context["conversation_history"] = conv_history
+        if conv_history:
+            logger.info(f"Loaded {len(conv_history)} previous turns for context")
         
         # Detect intent first
         intent = intent_classifier.classify(request.message)
         logger.info(f"Intent: {intent['primary_intent']} ({intent['confidence']})")
         
+        # Check if this is a field comparison query
+        is_comparison_query = intent_classifier.is_field_comparison_query(
+            request.message, field_names
+        )
+        mentioned_fields = intent_classifier.extract_field_names(
+            request.message, field_names
+        )
+        
+        if is_comparison_query and len(mentioned_fields) >= 1:
+            logger.info(f"Field comparison detected - fields: {mentioned_fields}")
+            context["comparison_requested"] = True
+            context["mentioned_fields"] = mentioned_fields
+            
+            # Fetch satellite data for each mentioned field
+            comparison_contexts = {}
+            for field_name in mentioned_fields:
+                field_data = next(
+                    (f for f in all_user_fields if f.get("name") == field_name), 
+                    None
+                )
+                if field_data:
+                    # Build coordinates from field data
+                    field_coords = build_field_coordinates(field_data)
+                    if field_coords:
+                        try:
+                            field_satellite = fetch_field_context(
+                                coordinates=field_coords,
+                                crop_type=field_data.get("crop_type", "Wheat"),
+                                area_acres=field_data.get("area_acres", 1.0),
+                                fetch_satellite=True
+                            )
+                            comparison_contexts[field_name] = {
+                                "field_info": field_data,
+                                "satellite_data": field_satellite
+                            }
+                            logger.info(f"Fetched data for comparison field: {field_name}")
+                        except Exception as e:
+                            logger.warning(f"Could not fetch data for {field_name}: {e}")
+            
+            context["comparison_fields"] = comparison_contexts
+        
         # Fetch satellite data for technical queries (vegetation, water, nutrient intents)
         satellite_intents = [
             "vegetation_health", "water_stress", "nutrient_status", 
-            "pest_disease", "forecast_query", "zone_specific", "action_recommendation"
+            "pest_disease", "forecast_query", "zone_specific", "action_recommendation",
+            "field_comparison"  # Also fetch for comparison queries
         ]
         if (intent["primary_intent"] in satellite_intents and 
             context.get("coordinates") and 
@@ -375,6 +547,16 @@ async def chat(request: ChatRequest):
             context_used=list(context_priority.get("priority_1", []))
         )
         
+        # Save to session history for follow-up awareness
+        add_to_session_history(
+            request.session_id, "user", request.message, 
+            intent=intent["primary_intent"]
+        )
+        add_to_session_history(
+            request.session_id, "assistant", response_text,
+            diagnosis=diagnosis
+        )
+        
         # Update session timestamp
         supabase.update_session_timestamp(request.session_id)
         

context_aggregator.py

@@ -96,7 +96,30 @@ class ContextAggregator:
             context["farmer_profile"] = farmer_context.get("profile", {})
             context["farmer_actions"] = farmer_context.get("actions", {})
         
-        # 4. Add previous analysis if available
+        # 4. Fetch comprehensive weather from Open-Meteo (free API)
+        weather = self._fetch_weather_openmeteo(center_lat, center_lon)
+        if weather:
+            context["weather"] = weather
+            logger.info("Weather data fetched from Open-Meteo")
+        
+        # 5. Compute historical trends from temporal data
+        if context.get("temporal_trends") or context.get("vegetation_indices"):
+            trends = self._compute_historical_trends(
+                context.get("vegetation_indices", {}),
+                context.get("temporal_trends", {})
+            )
+            context["historical_trends"] = trends
+            logger.info(f"Historical trends computed: {trends.get('summary', 'N/A')}")
+        
+        # 6. Identify priority zones from patches
+        patches = context.get("patches", []) + context.get("anomalies", {}).get("high_priority", [])
+        if patches:
+            zone_data = self._identify_priority_zones(patches)
+            context["zone_analysis"] = zone_data
+            if zone_data.get("most_critical"):
+                logger.info(f"Priority zone: {zone_data['most_critical'].get('location', 'N/A')}")
+        
+        # 7. Add previous analysis if available
         if sar_data:
             context["previous_analysis"] = {
                 "date": datetime.now().isoformat(),
@@ -401,6 +424,242 @@ class ContextAggregator:
             }
         }
     
+    def _fetch_weather_openmeteo(self, center_lat: float, center_lon: float) -> Dict:
+        """
+        Fetch comprehensive weather data from Open-Meteo (free API).
+        
+        Returns 7-day historical + 7-day forecast with rolling statistics
+        and actionable stress indicators.
+        """
+        try:
+            response = requests.get(
+                "https://api.open-meteo.com/v1/forecast",
+                params={
+                    "latitude": center_lat,
+                    "longitude": center_lon,
+                    "daily": "temperature_2m_max,temperature_2m_min,precipitation_sum,"
+                             "relative_humidity_2m_mean,wind_speed_10m_max,"
+                             "et0_fao_evapotranspiration",
+                    "past_days": 7,
+                    "forecast_days": 7,
+                    "timezone": "Asia/Kolkata"
+                },
+                timeout=30
+            )
+            
+            if response.status_code == 200:
+                return self._structure_weather_response(response.json())
+            else:
+                logger.warning(f"Open-Meteo returned status {response.status_code}")
+                return {}
+                
+        except Exception as e:
+            logger.warning(f"Weather fetch error: {e}")
+            return {}
+    
+    def _structure_weather_response(self, data: Dict) -> Dict:
+        """Structure weather API response into historical + forecast + stats."""
+        daily = data.get("daily", {})
+        dates = daily.get("time", [])
+        
+        if not dates:
+            return {}
+        
+        # Split into historical (first 7) and forecast (last 7)
+        historical = []
+        forecast = []
+        today_idx = min(7, len(dates))
+        
+        for i, date in enumerate(dates):
+            entry = {
+                "date": date,
+                "temp_max": daily.get("temperature_2m_max", [None] * len(dates))[i],
+                "temp_min": daily.get("temperature_2m_min", [None] * len(dates))[i],
+                "precipitation": daily.get("precipitation_sum", [None] * len(dates))[i],
+                "humidity": daily.get("relative_humidity_2m_mean", [None] * len(dates))[i],
+                "wind": daily.get("wind_speed_10m_max", [None] * len(dates))[i],
+                "et0": daily.get("et0_fao_evapotranspiration", [None] * len(dates))[i]
+            }
+            if i < today_idx:
+                historical.append(entry)
+            else:
+                forecast.append(entry)
+        
+        return {
+            "historical_7d": historical,
+            "forecast_7d": forecast,
+            "rolling_stats": self._compute_weather_rolling_stats(historical),
+            "stress_indicators": self._detect_weather_stress_indicators(historical, forecast)
+        }
+    
+    def _compute_weather_rolling_stats(self, data: List[Dict]) -> Dict:
+        """Compute rolling weather statistics for the past 7 days."""
+        temps = [d["temp_max"] for d in data if d.get("temp_max") is not None]
+        precip = [d["precipitation"] for d in data if d.get("precipitation") is not None]
+        humidity = [d["humidity"] for d in data if d.get("humidity") is not None]
+        et0 = [d["et0"] for d in data if d.get("et0") is not None]
+        
+        return {
+            "avg_temp_7d": round(sum(temps) / len(temps), 1) if temps else None,
+            "max_temp_7d": max(temps) if temps else None,
+            "min_temp_7d": min(temps) if temps else None,
+            "total_precip_7d": round(sum(precip), 1) if precip else 0,
+            "dry_days_count": sum(1 for p in precip if p == 0),
+            "heat_stress_days": sum(1 for t in temps if t > 35),
+            "avg_humidity_7d": round(sum(humidity) / len(humidity), 1) if humidity else None,
+            "total_et0_7d": round(sum(et0), 1) if et0 else None
+        }
+    
+    def _detect_weather_stress_indicators(self, hist: List[Dict], fore: List[Dict]) -> Dict:
+        """Detect actionable weather stress indicators."""
+        h_temps = [d["temp_max"] for d in hist if d.get("temp_max")]
+        f_temps = [d["temp_max"] for d in fore if d.get("temp_max")]
+        h_precip = sum((d.get("precipitation") or 0) for d in hist)
+        f_precip = sum((d.get("precipitation") or 0) for d in fore)
+        
+        # Check if recent 3 days or upcoming 3 days have heat stress
+        recent_3_heat = any(t > 38 for t in h_temps[-3:]) if len(h_temps) >= 3 else False
+        upcoming_3_heat = any(t > 38 for t in f_temps[:3]) if len(f_temps) >= 3 else False
+        
+        return {
+            "current_heat_stress": recent_3_heat,
+            "predicted_heat_stress": upcoming_3_heat,
+            "drought_risk": h_precip < 10 and f_precip < 5,
+            "flood_risk": f_precip > 100,
+            "suitable_for_irrigation": f_precip < 5 and max(f_temps[:3] or [30]) < 40,
+            "suitable_for_spraying": f_precip < 2 and max(f_temps[:2] or [30]) < 35
+        }
+
+    def _compute_historical_trends(self, current_indices: Dict, 
+                                    temporal_trends: Dict) -> Dict:
+        """
+        Compute historical trend metrics comparing current vs past data.
+        
+        Returns trend direction (improving/declining/stable) and change percentages.
+        """
+        trends = {"changes": {}}
+        
+        # Try to compute NDVI trends
+        ndvi_history = temporal_trends.get("ndvi", [])
+        current_ndvi = current_indices.get("ndvi")
+        
+        if current_ndvi and len(ndvi_history) >= 2:
+            # Get value from 7 days ago if available
+            week_ago_idx = min(6, len(ndvi_history) - 1)
+            week_ago = ndvi_history[week_ago_idx].get("value", current_ndvi)
+            
+            change_7d = current_ndvi - week_ago
+            trends["changes"]["ndvi_change_7d"] = round(change_7d, 4)
+            trends["changes"]["ndvi_pct_change_7d"] = round((change_7d / week_ago * 100) if week_ago else 0, 1)
+            
+            # Classify trend
+            if change_7d > 0.03:
+                trends["ndvi_trend"] = "improving"
+            elif change_7d < -0.03:
+                trends["ndvi_trend"] = "declining"
+            else:
+                trends["ndvi_trend"] = "stable"
+        
+        # Try to compute SMI trends (soil moisture)
+        smi_history = temporal_trends.get("smi", [])
+        current_smi = current_indices.get("smi")
+        
+        if current_smi and len(smi_history) >= 2:
+            week_ago_smi = smi_history[min(6, len(smi_history) - 1)].get("value", current_smi)
+            change_smi = current_smi - week_ago_smi
+            trends["changes"]["smi_change_7d"] = round(change_smi, 3)
+            
+            if change_smi > 0.05:
+                trends["smi_trend"] = "wetter"
+            elif change_smi < -0.05:
+                trends["smi_trend"] = "drier"
+            else:
+                trends["smi_trend"] = "stable"
+        
+        # Generate summary
+        summaries = []
+        if trends.get("ndvi_trend"):
+            pct = abs(trends["changes"].get("ndvi_pct_change_7d", 0))
+            summaries.append(f"Vegetation {trends['ndvi_trend']} ({pct:.0f}% change)")
+        if trends.get("smi_trend"):
+            summaries.append(f"Soil {trends['smi_trend']}")
+        
+        trends["summary"] = "; ".join(summaries) if summaries else "Insufficient historical data"
+        
+        return trends
+
+    def _identify_priority_zones(self, patches: List[Dict]) -> Dict:
+        """
+        Identify zones/patches that need the most attention based on stress scores.
+        
+        Returns top 3 priority zones with location and issue details.
+        """
+        if not patches:
+            return {"priority_zones": [], "most_critical": None, "total_affected_area_pct": 0}
+        
+        # Sort patches by stress score (highest first)
+        stressed = sorted(
+            [p for p in patches if p.get("stress_score", 0) > 0.3],
+            key=lambda p: p.get("stress_score", 0),
+            reverse=True
+        )
+        
+        priority_zones = []
+        for patch in stressed[:3]:  # Top 3 stressed zones
+            # Determine location description
+            location = patch.get("location_description")
+            if not location:
+                # Try to infer from coordinates or patch_id
+                patch_id = patch.get("patch_id", patch.get("id", "Unknown"))
+                location = self._infer_location_from_patch(patch_id, patch)
+            
+            priority_zones.append({
+                "zone_id": patch.get("patch_id", patch.get("id")),
+                "location": location,
+                "stress_score": round(patch.get("stress_score", 0), 2),
+                "primary_issue": patch.get("predicted_issue", patch.get("issue", "stress detected")),
+                "area_percentage": round(patch.get("area_pct", patch.get("area_percentage", 0)), 1),
+                "recommended_action": patch.get("recommended_action", "monitor closely")
+            })
+        
+        total_affected = sum(z["area_percentage"] for z in priority_zones)
+        
+        return {
+            "priority_zones": priority_zones,
+            "most_critical": priority_zones[0] if priority_zones else None,
+            "total_affected_area_pct": round(total_affected, 1),
+            "zones_count": len(priority_zones)
+        }
+    
+    def _infer_location_from_patch(self, patch_id: str, patch: Dict) -> str:
+        """Infer human-readable location from patch data."""
+        # Common quadrant mappings
+        quadrant_map = {
+            "NE": "Northeast corner",
+            "NW": "Northwest corner", 
+            "SE": "Southeast corner",
+            "SW": "Southwest corner",
+            "N": "Northern section",
+            "S": "Southern section",
+            "E": "Eastern section",
+            "W": "Western section",
+            "C": "Central area"
+        }
+        
+        # Try to extract quadrant from patch_id
+        patch_str = str(patch_id).upper()
+        for abbr, name in quadrant_map.items():
+            if abbr in patch_str:
+                return name
+        
+        # Fall back to numbered zone
+        if isinstance(patch_id, int) or patch_str.isdigit():
+            return f"Zone {patch_id}"
+        
+        return f"Zone {patch_str}"
+
+
+    
     # =========================================================================
     # PRIORITY-BASED CONTEXT FORMATTING
     # =========================================================================

intent_classifier.py

@@ -126,6 +126,21 @@ INTENT_PATTERNS = {
         "priority": 8
     },
     
+    "field_comparison": {
+        "keywords": [
+            "compare", "comparison", "versus", " vs ", "other field", "another field",
+            "between fields", "both fields", "which field", "differ", "different field",
+            "my other", "second field", "first field"
+        ],
+        "phrases": [
+            "compare with", "compared to my", "how does my * compare", "between my fields",
+            "which field is better", "difference between", "compare * and *",
+            "other farm", "other farmland", "another farm"
+        ],
+        "sub_intents": ["multi_field_analysis", "field_ranking", "relative_health"],
+        "priority": 2
+    },
+    
     "general_query": {
         "keywords": [
             "what", "how", "why", "tell", "about", "explain", "hello", "hi",
@@ -267,6 +282,78 @@ class IntentClassifier:
         
         return sub_intents if sub_intents else ["general"]
     
+    def extract_field_names(self, query: str, available_fields: List[str]) -> List[str]:
+        """
+        Extract field names mentioned in the query.
+        
+        This enables dynamic field comparison - when a user mentions
+        another field name, we can fetch data for that field and compare.
+        
+        Args:
+            query: User's message
+            available_fields: List of user's registered field names
+            
+        Returns:
+            List of detected field names (in order of appearance)
+        """
+        if not available_fields:
+            return []
+        
+        query_lower = query.lower()
+        detected = []
+        
+        # Check each registered field name
+        for field_name in available_fields:
+            if not field_name:
+                continue
+            # Check if field name appears in query (case-insensitive)
+            if field_name.lower() in query_lower:
+                detected.append(field_name)
+        
+        # Also check for ordinal patterns like "field 1", "field 2", "first field"
+        ordinal_map = {
+            "first": 0, "1st": 0, "field 1": 0, "field one": 0,
+            "second": 1, "2nd": 1, "field 2": 1, "field two": 1,
+            "third": 2, "3rd": 2, "field 3": 2, "field three": 2
+        }
+        
+        for pattern, idx in ordinal_map.items():
+            if pattern in query_lower and idx < len(available_fields):
+                field = available_fields[idx]
+                if field not in detected:
+                    detected.append(field)
+        
+        return detected
+    
+    def is_field_comparison_query(self, query: str, available_fields: List[str]) -> bool:
+        """
+        Check if the query is asking to compare multiple fields.
+        
+        Returns True if:
+        1. Multiple field names are mentioned, OR
+        2. Comparison keywords + at least one field name
+        """
+        intent = self.classify(query)
+        mentioned_fields = self.extract_field_names(query, available_fields)
+        
+        # Multiple fields mentioned
+        if len(mentioned_fields) >= 2:
+            return True
+        
+        # Comparison intent + at least one field mentioned
+        if intent["primary_intent"] in ["field_comparison", "comparison"]:
+            if len(mentioned_fields) >= 1:
+                return True
+            # Check for phrases like "other field", "another farm"
+            comparison_phrases = ["other field", "another field", "other farm", "another farm", 
+                                  "my other", "between fields"]
+            query_lower = query.lower()
+            for phrase in comparison_phrases:
+                if phrase in query_lower:
+                    return True
+        
+        return False
+    
     def _default_response(self) -> Dict:
         """Return default classification for unrecognized queries."""
         return {

prompts.py

@@ -5,6 +5,212 @@ Prompts for each stage: Claim → Validate → Contradict → Confirm
 Following the Developer Specification exactly.
 """
 
+from typing import Dict, List, Any, Optional
+
+# =============================================================================
+# PERSONA SYSTEM - Tailored Responses Based on User Profile
+# =============================================================================
+
+# Granular persona definitions based on role, experience, and context
+PERSONA_DEFINITIONS = {
+    "new_farmer_basic_tech": {
+        "description": "New farmer (0-3 years), limited smartphone familiarity",
+        "style": "Very simple, step-by-step guidance with visual cues",
+        "format": "Short bullet points, numbered steps, clear YES/NO answers",
+        "focus": "Immediate actions today, what to look for visually, when to seek help",
+        "tone": "Warm, patient, encouraging, supportive",
+        "recommendations": "Simple low-cost solutions, avoid complex equipment suggestions"
+    },
+    "new_farmer_tech_savvy": {
+        "description": "New farmer (0-3 years), comfortable with technology",
+        "style": "Clear explanations with some context, can reference app features",
+        "format": "Organized lists, basic metrics explained, graphs mentioned",
+        "focus": "Learning-oriented, explain the 'why', build understanding",
+        "tone": "Friendly, educational, encouraging experimentation",
+        "recommendations": "Modern approaches welcome, mention monitoring features"
+    },
+    "experienced_farmer_traditional": {
+        "description": "Experienced farmer (5+ years), prefers traditional methods",
+        "style": "Practical, reference seasonal patterns they would recognize",
+        "format": "Direct recommendations, compare to normal conditions",
+        "focus": "Cost-effective proven solutions, risk assessment, timing",
+        "tone": "Respectful of expertise, collaborative, peer-to-peer",
+        "recommendations": "Proven methods first, new tech only if clearly beneficial"
+    },
+    "experienced_farmer_innovative": {
+        "description": "Experienced farmer (5+ years), open to modern methods",
+        "style": "Practical with technical context, efficiency-focused",
+        "format": "Data-backed recommendations, optimization suggestions",
+        "focus": "Maximize yield/profit, precision timing, resource efficiency",
+        "tone": "Professional, partner-like, respects their judgment",
+        "recommendations": "Innovation welcomed, precision agriculture approaches"
+    },
+    "commercial_farmer": {
+        "description": "Commercial farming focus, business-oriented",
+        "style": "Business-focused, ROI considerations, scalable solutions",
+        "format": "Clear priorities, cost-benefit mentioned, zone-wise breakdown",
+        "focus": "Profit optimization, risk management, market timing",
+        "tone": "Professional, efficient, results-oriented",
+        "recommendations": "Commercial-grade solutions, labor/resource optimization"
+    },
+    "agricultural_officer": {
+        "description": "Extension officer or field advisor",
+        "style": "Professional, documentation-ready, multi-farm applicable",
+        "format": "Structured findings, zone-wise data, statistical summary",
+        "focus": "Regional patterns, farmer communication tips, policy relevance",
+        "tone": "Formal, comprehensive, shareable insights",
+        "recommendations": "Scalable solutions, training opportunities"
+    },
+    "agronomist_researcher": {
+        "description": "Technical researcher or scientist",
+        "style": "Full technical precision, spectral indices, statistical rigor",
+        "format": "Numerical tables, temporal correlations, spatial patterns, confidence intervals",
+        "focus": "Causal mechanisms, data quality notes, methodology",
+        "tone": "Scientific, analytical, evidence-driven",
+        "recommendations": "Research-backed interventions, experimental approaches"
+    }
+}
+
+# Questionnaire key mappings
+EXPERIENCE_MAP = {
+    "Less than 2 years": 1,
+    "2 - 5 years": 3,
+    "5 - 10 years": 7,
+    "More than 10 years": 15
+}
+
+TECH_COMFORT_MAP = {
+    "I don't know how to use them": "basic",
+    "I need help using them": "basic",
+    "I can use basic features (calls, WhatsApp, YouTube)": "moderate",
+    "I am very comfortable using apps": "advanced"
+}
+
+INNOVATION_MAP = {
+    "I prefer traditional methods": "traditional",
+    "I try new methods occasionally": "moderate",
+    "I regularly adopt modern/innovative methods": "innovative"
+}
+
+FARMING_GOAL_MAP = {
+    "Food for family consumption": "subsistence",
+    "Earn Income / Livelihood": "income",
+    "Sell Commercially / Business": "commercial",
+    "Other": "custom"
+}
+
+
+def create_user_persona(user_profile: Dict, all_fields: List = None) -> Dict:
+    """
+    Create a comprehensive user persona from questionnaire data.
+    
+    Uses all available context: role, experience, smartphone familiarity,
+    innovation attitude, farming goals, irrigation methods, mechanization,
+    and cropping frequency to tailor responses appropriately.
+    
+    Args:
+        user_profile: User profile dict with 'questionnaire_data' key
+        all_fields: List of user's field info dicts
+        
+    Returns:
+        Persona dict with instructions for response generation
+    """
+    questionnaire = user_profile.get("questionnaire_data", {}) if user_profile else {}
+    
+    # Extract all questionnaire answers
+    role = questionnaire.get("role", "Farmer")
+    age_group = questionnaire.get("age_group", "31 - 45")
+    farming_exp = questionnaire.get("farming_experience", "2 - 5 years")
+    smartphone = questionnaire.get("smartphone_familiarity", "I can use basic features (calls, WhatsApp, YouTube)")
+    innovation = questionnaire.get("innovation_attitude", "I try new methods occasionally")
+    farming_goal = questionnaire.get("farming_goal", "Earn Income / Livelihood")
+    irrigation = questionnaire.get("irrigation_source", "Tube well / Borewell")
+    mechanization = questionnaire.get("mechanization_level", "with both by hand and machines")
+    cropping_freq = questionnaire.get("cropping_frequency", "2 crops per year")
+    
+    # Map to numeric and categorical values
+    years_experience = EXPERIENCE_MAP.get(farming_exp, 3)
+    tech_level = TECH_COMFORT_MAP.get(smartphone, "moderate")
+    innovation_level = INNOVATION_MAP.get(innovation, "moderate")
+    goal_type = FARMING_GOAL_MAP.get(farming_goal, "income")
+    
+    # Determine persona type based on combined factors
+    if role == "Agro-tech Researcher":
+        persona_type = "agronomist_researcher"
+    elif role in ["Extension Officer", "Agricultural Officer"]:
+        persona_type = "agricultural_officer"
+    elif goal_type == "commercial":
+        persona_type = "commercial_farmer"
+    elif years_experience <= 3:
+        if tech_level == "advanced":
+            persona_type = "new_farmer_tech_savvy"
+        else:
+            persona_type = "new_farmer_basic_tech"
+    else:
+        if innovation_level == "innovative":
+            persona_type = "experienced_farmer_innovative"
+        else:
+            persona_type = "experienced_farmer_traditional"
+    
+    persona_def = PERSONA_DEFINITIONS.get(persona_type, PERSONA_DEFINITIONS["experienced_farmer_traditional"])
+    
+    # Build context-aware persona instructions
+    persona_instructions = f"""
+USER PERSONA: {persona_def['description']}
+
+COMMUNICATION STYLE: {persona_def['style']}
+RESPONSE FORMAT: {persona_def['format']}
+PRIMARY FOCUS: {persona_def['focus']}
+TONE: {persona_def['tone']}
+RECOMMENDATION STYLE: {persona_def['recommendations']}
+
+USER CONTEXT FOR TAILORING:
+- Farming Experience: {farming_exp} ({years_experience} years)
+- Technology Comfort: {smartphone}
+- Innovation Attitude: {innovation}
+- Farming Goal: {farming_goal}
+- Irrigation Method: {irrigation}
+- Mechanization: {mechanization}
+- Cropping Frequency: {cropping_freq}
+
+TAILORING GUIDELINES:
+1. Match recommendations to their IRRIGATION method ({irrigation}):
+   - For "Rain only": Focus on rainwater harvesting, moisture conservation
+   - For "Drip/Sprinkler": Can suggest precise application rates
+   - For "Tube well": Consider water table sustainability
+   
+2. Match recommendations to their MECHANIZATION level ({mechanization}):
+   - For "by hand": Suggest labor-manageable solutions
+   - For "with machines": Can suggest mechanized interventions
+   
+3. Align with their FARMING GOAL ({farming_goal}):
+   - Subsistence: Prioritize food security, low-cost solutions
+   - Income: Balance cost and yield improvements
+   - Commercial: Focus on ROI, market timing, quality
+
+4. Respect their INNOVATION preference ({innovation}):
+   - Traditional: Lead with proven methods, new tech as optional
+   - Innovative: Can suggest modern precision approaches
+
+IMPORTANT: Generate a response that this specific user will find most helpful and actionable.
+"""
+
+    return {
+        "type": persona_type,
+        "experience_years": years_experience,
+        "tech_level": tech_level,
+        "innovation_level": innovation_level,
+        "goal_type": goal_type,
+        "irrigation_method": irrigation,
+        "mechanization": mechanization,
+        "cropping_frequency": cropping_freq,
+        "all_fields": [f.get("name") for f in (all_fields or [])],
+        "instructions": persona_instructions,
+        "raw_questionnaire": questionnaire
+    }
+
+
+
 # =============================================================================
 # SYSTEM PROMPT (Base context)
 # =============================================================================
@@ -155,32 +361,183 @@ Return ONLY the JSON object, no additional text."""
 # RESPONSE GENERATION PROMPT
 # =============================================================================
 
-RESPONSE_PROMPT = """Based on this diagnostic analysis, generate a helpful response for the farmer.
+RESPONSE_PROMPT = """
+{persona_instructions}
+
+CONVERSATION HISTORY (for follow-up awareness):
+{conversation_history}
+
+Based on the diagnostic analysis, generate a FOCUSED, TO-THE-POINT response.
+
+USER QUERY: {query}
+
+DIAGNOSIS: {diagnosis}
+
+EVIDENCE: {evidence}
+
+WEATHER: {weather_context}
+
+ZONE ANALYSIS:
+{zone_context}
+
+HISTORICAL TRENDS:
+{trend_context}
+
+═══════════════════════════════════════════════════════════════
+CRITICAL: RESPONSE STRUCTURE (MUST FOLLOW THIS ORDER)
+═══════════════════════════════════════════════════════════════
+
+**SECTION 1: DIRECT ANSWER (2-3 sentences MAX)**
+- Answer the user's EXACT question immediately
+- No preamble, no explanation - just the answer
+- If it's a yes/no question, start with "Yes" or "No"
+- Include the key data point that supports your answer
+
+**SECTION 2: BRIEF EVIDENCE (1-2 bullets)**
+- Only cite 1-2 most relevant data points
+- Format: "📊 NDVI: 0.45 (below healthy threshold of 0.6)"
+
+**SECTION 3: PRIORITY ACTION (1 main action)**
+- ONE clear, immediate action they should take
+- Include timing: "Do this TODAY/this week/before rain"
+
+---
+
+**SECTION 4: AUXILIARY INFORMATION** (only if relevant)
+After the main answer, you MAY add:
+- 🌤️ Weather timing (if relevant to action)
+- 📍 Zone priority (if spatial variation exists)
+- 📈 Trend context (if historical data shows pattern)
+- 💡 Additional tips (max 2 bullets)
+
+═══════════════════════════════════════════════════════════════
+WRONG ❌: "Based on the satellite analysis of your field, I can see that there are several factors to consider. The NDVI values show..."
+RIGHT ✅: "Your crop needs water immediately. NDVI is 0.42, down 15% from last week, indicating water stress."
+═══════════════════════════════════════════════════════════════
+
+FOLLOW-UP AWARENESS:
+- If user asks "what about X" after previous discussion, connect to earlier context
+- Reference previous diagnosis if relevant: "Building on the water stress we discussed..."
+
+ZONE-SPECIFIC (if zone data available):
+- Identify the PRIORITY ZONE needing immediate attention
+- Give zone-specific dosage/quantity if applicable
+
+Keep total response under 150 words for basic farmers, up to 250 for researchers."""
+
+
+# =============================================================================
+# CONFIDENCE-BASED RESPONSE PROMPTS
+# =============================================================================
+
+LOW_CONFIDENCE_PROMPT = """
+{persona_instructions}
+
+I need more information to give you a confident answer.
+
+WHAT I CAN SEE:
+{available_evidence}
+
+WHAT'S UNCLEAR:
+{missing_info}
+
+**Before I can help accurately, please tell me:**
+{clarifying_questions}
+
+Once you provide this information, I can give you specific recommendations.
+"""
+
+MEDIUM_CONFIDENCE_PROMPT = """
+{persona_instructions}
 
 USER QUERY: {query}
 
-DIAGNOSIS RESULT:
+Based on available data, here's my analysis (with some uncertainty):
+
 {diagnosis}
 
-EVIDENCE SUMMARY:
-{evidence}
+⚠️ **Note:** My confidence is moderate because:
+{uncertainty_reasons}
+
+**Recommended action:**
+{recommendation}
+
+**To be more certain, it would help to know:**
+{additional_info_needed}
+"""
+
+# =============================================================================
+# ZONE-SPECIFIC CONTEXT BUILDER
+# =============================================================================
+
+def format_zone_context(zone_data: dict) -> str:
+    """Format zone/patch data into readable context for LLM."""
+    if not zone_data or not zone_data.get("priority_zones"):
+        return "No zone-specific data available."
+    
+    lines = []
+    zones = zone_data.get("priority_zones", [])
+    
+    if zones:
+        lines.append("PRIORITY ZONES (highest stress first):")
+        for i, zone in enumerate(zones[:3], 1):
+            lines.append(f"  {i}. {zone.get('location', 'Zone')} - "
+                        f"Stress: {zone.get('stress_score', 0):.0%}, "
+                        f"Issue: {zone.get('primary_issue', 'unknown')}, "
+                        f"Area: {zone.get('area_percentage', 0):.1f}%")
+    
+    most_critical = zone_data.get("most_critical")
+    if most_critical:
+        lines.append(f"\n⚠️ MOST CRITICAL: {most_critical.get('location', 'Zone')} "
+                    f"needs immediate attention")
+    
+    return "\n".join(lines) if lines else "No zone-specific data available."
+
+
+def format_trend_context(trend_data: dict) -> str:
+    """Format historical trend data into readable context for LLM."""
+    if not trend_data:
+        return "No historical trend data available."
+    
+    lines = []
+    changes = trend_data.get("changes", {})
+    
+    if changes.get("ndvi_change_7d") is not None:
+        change = changes["ndvi_change_7d"]
+        direction = "↑" if change > 0 else "↓" if change < 0 else "→"
+        lines.append(f"NDVI Change (7 days): {direction} {abs(change):.3f} "
+                    f"({trend_data.get('ndvi_trend', 'unknown')})")
+    
+    if changes.get("smi_change_7d") is not None:
+        change = changes["smi_change_7d"]
+        direction = "↑" if change > 0 else "↓" if change < 0 else "→"
+        lines.append(f"Soil Moisture Change: {direction} {abs(change):.2f}")
+    
+    summary = trend_data.get("summary")
+    if summary:
+        lines.append(f"Summary: {summary}")
+    
+    return "\n".join(lines) if lines else "No historical trend data available."
 
-Generate a response that:
-1. DIRECTLY answers the farmer's question first
-2. Explains the diagnosis in simple, practical terms
-3. Cites 2-3 key pieces of evidence with specific numbers
-4. Provides a clear causal chain if appropriate
-5. Gives prioritized, actionable recommendations
-6. Mentions which area needs most attention if spatial data available
-7. Is concise but complete (3-4 paragraphs max)
 
-FORMAT:
-- Use emojis sparingly for visual clarity: 📊 (data), 🔬 (analysis), ✅ (action), ⚠️ (warning)
-- Use **bold** for key findings
-- Use bullet points for recommendations
-- Avoid technical jargon - explain in farmer-friendly terms
+def format_conversation_history(history: list) -> str:
+    """Format conversation history for context injection."""
+    if not history:
+        return "This is the first message in the conversation."
+    
+    lines = ["Recent conversation:"]
+    for turn in history[-3:]:  # Last 3 turns
+        role = turn.get("role", "unknown")
+        content = turn.get("content", "")[:150]  # Truncate long messages
+        if role == "user":
+            lines.append(f"  User: {content}")
+        else:
+            # For assistant, show diagnosis summary if available
+            diagnosis = turn.get("diagnosis", content[:100])
+            lines.append(f"  Assistant: {diagnosis}")
+    
+    return "\n".join(lines)
 
-Respond in natural language (not JSON)."""
 
 # =============================================================================
 # FOLLOWUP GENERATION PROMPT
@@ -289,3 +646,80 @@ def generate_followup_questions(intent: str, diagnosis: str) -> list:
         "Is my crop at risk?",
         "How can I prevent this in the future?"
     ])
+
+
+# =============================================================================
+# FIELD COMPARISON PROMPT
+# =============================================================================
+
+COMPARISON_RESPONSE_PROMPT = """
+{persona_instructions}
+
+The user is asking to compare multiple fields. Analyze the data below and provide a comparative assessment.
+
+FIELDS BEING COMPARED:
+{comparison_data}
+
+WEATHER CONTEXT (shared for all fields):
+{weather_context}
+
+Generate a comparative response that:
+1. Creates a clear side-by-side summary of key health metrics for each field
+2. Explicitly states which field is performing BETTER and which needs MORE ATTENTION
+3. Identifies the KEY DIFFERENCES between fields and potential CAUSES
+4. Provides FIELD-SPECIFIC recommendations (different actions per field)
+5. Uses the weather forecast to suggest optimal timing for interventions
+6. Matches the user's persona communication style
+
+COMPARISON FORMAT:
+- Start with a quick overview (which field needs priority)
+- Use a structured comparison (Field A vs Field B)
+- End with specific action items per field
+
+Respond in natural language but use clear structure (headers, bullets) for easy comparison."""
+
+
+def format_weather_context(weather_data: dict) -> str:
+    """Format weather data into readable context for LLM."""
+    if not weather_data:
+        return "No weather data available."
+    
+    lines = []
+    
+    # Historical summary
+    hist = weather_data.get("rolling_stats", {})
+    if hist:
+        lines.append("PAST 7 DAYS:")
+        if hist.get("avg_temp_7d"):
+            lines.append(f"  - Average Max Temp: {hist['avg_temp_7d']}°C")
+        if hist.get("total_precip_7d") is not None:
+            lines.append(f"  - Total Rainfall: {hist['total_precip_7d']} mm")
+        if hist.get("dry_days_count") is not None:
+            lines.append(f"  - Dry Days: {hist['dry_days_count']}")
+        if hist.get("heat_stress_days") is not None:
+            lines.append(f"  - Heat Stress Days (>35°C): {hist['heat_stress_days']}")
+    
+    # Forecast summary
+    forecast = weather_data.get("forecast_7d", [])
+    if forecast:
+        lines.append("\nNEXT 7 DAYS FORECAST:")
+        for day in forecast[:3]:  # First 3 days
+            lines.append(f"  - {day.get('date', 'N/A')}: {day.get('temp_max', 'N/A')}°C, Rain: {day.get('precipitation', 0)}mm")
+    
+    # Stress indicators
+    stress = weather_data.get("stress_indicators", {})
+    if stress:
+        lines.append("\nWEATHER STRESS INDICATORS:")
+        if stress.get("current_heat_stress"):
+            lines.append("  ⚠️ Current heat stress detected")
+        if stress.get("predicted_heat_stress"):
+            lines.append("  ⚠️ Heat stress predicted in next 3 days")
+        if stress.get("drought_risk"):
+            lines.append("  ⚠️ Drought risk - low recent and forecast rainfall")
+        if stress.get("suitable_for_irrigation"):
+            lines.append("  ✅ Good conditions for irrigation")
+        if stress.get("suitable_for_spraying"):
+            lines.append("  ✅ Good conditions for pesticide/fertilizer application")
+    
+    return "\n".join(lines) if lines else "Weather data not available."
+