Full Developer Spec implementation: Priority-based Multi-Stage Reasoning

- models.py: Pydantic schemas for all data structures
- prompts.py: Enhanced LLM prompts with JSON output formats
- context_aggregator.py: Priority-based satellite data formatting
- reasoning_engine.py: 4-stage pipeline with evidence chains
- priority_mapper.py: Intent-to-context mapping per spec
- intent_classifier.py: Enhanced with phrases and regional support
- app.py: Spec-compliant response with suggested_followups

app.py

@@ -164,21 +164,35 @@ app.add_middleware(
 )
 
 # ============================================================================
-# REQUEST/RESPONSE MODELS
+# REQUEST/RESPONSE MODELS (Matching Developer Spec)
 # ============================================================================
 class ChatRequest(BaseModel):
     session_id: str
     message: str
     user_id: Optional[str] = None
     field_context: Optional[Dict[str, Any]] = None
+    field_name: Optional[str] = None  # Optional specific field
+
+class ResponseContent(BaseModel):
+    message: str
+    confidence: float
+    diagnosis: Optional[str] = None
+
+class ContextPriorityUsed(BaseModel):
+    priority_1: List[str] = []
+    priority_2: List[str] = []
+    priority_3: List[str] = []
+    priority_4: List[str] = []
 
 class ChatResponse(BaseModel):
-    response: str
+    """Full response matching developer spec."""
+    response: ResponseContent
     session_id: str
     message_id: str
-    context_used: List[str]
     timestamp: str
     reasoning_trace: Optional[Dict[str, Any]] = None
+    context_priority_used: Optional[ContextPriorityUsed] = None
+    suggested_followups: List[str] = []
 
 class SessionRequest(BaseModel):
     user_id: str
@@ -199,6 +213,7 @@ class HistoryResponse(BaseModel):
     session_id: str
     messages: List[MessageModel]
 
+
 # ============================================================================
 # API ENDPOINTS
 # ============================================================================
@@ -321,7 +336,11 @@ async def chat(request: ChatRequest):
                 query=request.message,
                 context=context
             )
-            context_used = list(reasoning_trace.get("evidence_summary", {}).get("primary", []))
+            # Extract context priority info from trace
+            context_priority = reasoning_trace.get("context_priority_used", {})
+            diagnosis = reasoning_trace.get("stages", {}).get("confirmation", {}).get("final")
+            confidence = reasoning_trace.get("stages", {}).get("confirmation", {}).get("confidence", 0.7)
+            suggested_followups = reasoning_trace.get("suggested_followups", [])
         else:
             # Simple single-stage response
             logger.info("Using simple response mode")
@@ -335,14 +354,22 @@ async def chat(request: ChatRequest):
                 "intent": intent,
                 "field_context": context.get("user_field") if context else None
             }
-            context_used = list(context.keys()) if context else []
+            context_priority = {}
+            diagnosis = None
+            confidence = 0.5
+            # Generate simple followups
+            from prompts import generate_followup_questions
+            suggested_followups = generate_followup_questions(
+                intent["primary_intent"], 
+                "general"
+            )
         
         # Save assistant response
         assistant_msg_id = supabase.add_message(
             session_id=request.session_id,
             role="assistant",
             content=response_text,
-            context_used=context_used
+            context_used=list(context_priority.get("priority_1", []))
         )
         
         # Update session timestamp
@@ -350,13 +377,24 @@ async def chat(request: ChatRequest):
         
         logger.info(f"Response generated - {len(response_text)} chars")
         
+        # Build spec-compliant response
         return ChatResponse(
-            response=response_text,
+            response=ResponseContent(
+                message=response_text,
+                confidence=confidence,
+                diagnosis=diagnosis
+            ),
             session_id=request.session_id,
             message_id=assistant_msg_id,
-            context_used=context_used,
             timestamp=datetime.now().isoformat(),
-            reasoning_trace=reasoning_trace
+            reasoning_trace=reasoning_trace,
+            context_priority_used=ContextPriorityUsed(
+                priority_1=context_priority.get("priority_1", []),
+                priority_2=context_priority.get("priority_2", []),
+                priority_3=context_priority.get("priority_3", []),
+                priority_4=context_priority.get("priority_4", [])
+            ) if context_priority else None,
+            suggested_followups=suggested_followups
         )
         
     except Exception as e:

context_aggregator.py

@@ -1,31 +1,34 @@
 """
 Context Aggregator for Agricultural Chatbot
 =============================================
-Fetches satellite data from HF Space APIs and formats for LLM context.
+Fetches satellite data from HF Space APIs and formats for priority-based retrieval.
+Supports all data sources: SAR, Sentinel-2, Heatmap, Weather APIs.
 """
 
 import os
 import logging
 import requests
 from typing import Dict, List, Any, Optional
-from datetime import datetime
+from datetime import datetime, timedelta
 
 logger = logging.getLogger("ContextAggregator")
 
-# HF Space URLs
-SAR_API_URL = "https://aniket2006-agrow-backend-v2.hf.space"
-SENTINEL2_API_URL = "https://aniket2006-agrow-sentinel2.hf.space"
-HEATMAP_API_URL = "https://aniket2006-heatmap.hf.space"
+# HF Space URLs - Your deployed backends
+SAR_API_URL = os.getenv("SAR_API_URL", "https://aniket2006-agrow-backend-v2.hf.space")
+SENTINEL2_API_URL = os.getenv("SENTINEL2_API_URL", "https://aniket2006-agrow-sentinel2.hf.space")
+HEATMAP_API_URL = os.getenv("HEATMAP_API_URL", "https://aniket2006-heatmap.hf.space")
 
 
 class ContextAggregator:
     """
     Aggregates satellite data from multiple HF Space APIs.
-    Returns structured JSON for LLM context injection.
+    Returns structured data organized by priority levels for reasoning stages.
     """
     
-    def __init__(self, timeout: int = 30):
+    def __init__(self, timeout: int = 45):
         self.timeout = timeout
+        self._cache = {}
+        self._cache_ttl = 300  # 5 minutes
     
     def fetch_full_context(
         self,
@@ -38,20 +41,13 @@ class ContextAggregator:
         Fetch complete satellite context for a field.
         
         Args:
-            coordinates: {"center_lat": float, "center_lon": float, "bbox": [lon_min, lat_min, lon_max, lat_max]}
+            coordinates: {"center_lat": float, "center_lon": float, "bbox": [...]}
             crop_type: Type of crop
             area_acres: Field size in acres
-            farmer_context: Additional farmer profile data
+            farmer_context: Farmer profile and action data
             
         Returns:
-            {
-                "vegetation_indices": {...},
-                "sar_data": {...},
-                "soil_indicators": {...},
-                "weather_data": {...},
-                "anomalies": {...},
-                "temporal_trends": {...}
-            }
+            Structured context with all satellite data
         """
         context = {
             "fetch_timestamp": datetime.now().isoformat(),
@@ -72,23 +68,41 @@ class ContextAggregator:
         if not center_lat or not center_lon:
             return context
         
-        # Fetch SAR analysis (VV, VH bands, patches, predictions)
+        # 1. Fetch SAR analysis (VV, VH bands, patches, predictions)
         sar_data = self._fetch_sar_data(bbox, crop_type, farmer_context)
         if sar_data:
-            context["sar_bands"] = sar_data.get("sar_bands", {})
+            context["sar_bands"] = self._extract_sar_bands(sar_data)
             context["patches"] = sar_data.get("patches", [])
-            context["stressed_patches"] = sar_data.get("stressed_patches", [])
+            context["stressed_patches"] = [p for p in sar_data.get("patches", []) 
+                                           if p.get("stress_score", 0) > 0.5]
             context["health_summary"] = sar_data.get("health_summary", {})
             context["temporal_trends"] = sar_data.get("temporal_trends", {})
             context["weather_data"] = sar_data.get("weather_data", [])
         
-        # Fetch Sentinel-2 analysis (vegetation indices)
-        s2_data = self._fetch_sentinel2_data(center_lat, center_lon, crop_type, area_acres, farmer_context)
+        # 2. Fetch Sentinel-2 analysis (vegetation indices)
+        field_hectares = area_acres * 0.404686
+        s2_data = self._fetch_sentinel2_data(center_lat, center_lon, crop_type, 
+                                             field_hectares, farmer_context)
         if s2_data:
-            context["vegetation_indices"] = s2_data.get("vegetation_indices", {})
-            context["soil_indicators"] = s2_data.get("soil_indicators", {})
+            context["vegetation_indices"] = self._extract_vegetation_indices(s2_data)
+            context["soil_indicators"] = self._extract_soil_indicators(s2_data)
             context["llm_analysis"] = s2_data.get("llm_analysis", {})
             context["sentinel2_bands"] = s2_data.get("band_values", {})
+            context["clustering"] = self._extract_clustering(s2_data)
+            context["anomalies"] = self._extract_anomalies(s2_data)
+        
+        # 3. Add farmer context if provided
+        if farmer_context:
+            context["farmer_profile"] = farmer_context.get("profile", {})
+            context["farmer_actions"] = farmer_context.get("actions", {})
+        
+        # 4. Add previous analysis if available
+        if sar_data:
+            context["previous_analysis"] = {
+                "date": datetime.now().isoformat(),
+                "source": "sar_analysis",
+                "summary": sar_data.get("llm_analysis", {}).get("summary", "")
+            }
         
         return context
     
@@ -131,13 +145,11 @@ class ContextAggregator:
         center_lat: float,
         center_lon: float,
         crop_type: str,
-        area_acres: float,
+        field_hectares: float,
         farmer_context: Optional[Dict]
     ) -> Optional[Dict]:
         """Fetch Sentinel-2 analysis from HF Space."""
         try:
-            field_hectares = area_acres * 0.404686  # Convert acres to hectares
-            
             response = requests.post(
                 f"{SENTINEL2_API_URL}/analyze",
                 json={
@@ -163,176 +175,358 @@ class ContextAggregator:
             logger.error(f"Sentinel-2 fetch error: {e}")
             return None
     
-    def fetch_specific_metrics(
+    def _fetch_heatmap_metric(
         self,
         center_lat: float,
         center_lon: float,
-        area_acres: float,
-        metrics: List[str]
-    ) -> Dict[str, Any]:
-        """
-        Fetch specific heatmap metrics.
-        
-        Metrics: soil_moisture, soil_organic_matter, soil_fertility, 
-                 soil_salinity, greenness, nitrogen_level, 
-                 photosynthetic_capacity, pest_risk, disease_risk
-        """
-        results = {}
-        field_hectares = area_acres * 0.404686
-        
-        for metric in metrics:
-            try:
-                response = requests.post(
-                    f"{HEATMAP_API_URL}/generate-heatmap",
-                    json={
-                        "center_lat": center_lat,
-                        "center_lon": center_lon,
-                        "field_size_hectares": field_hectares,
-                        "metric": metric,
-                        "gaussian_sigma": 1.5,
-                        "show_field_boundary": False
-                    },
-                    timeout=60
-                )
+        field_hectares: float,
+        metric: str
+    ) -> Optional[Dict]:
+        """Fetch a specific heatmap metric."""
+        try:
+            response = requests.post(
+                f"{HEATMAP_API_URL}/generate-heatmap",
+                json={
+                    "center_lat": center_lat,
+                    "center_lon": center_lon,
+                    "field_size_hectares": field_hectares,
+                    "metric": metric,
+                    "gaussian_sigma": 1.5,
+                    "show_field_boundary": False
+                },
+                timeout=60
+            )
+            
+            if response.status_code == 200:
+                return response.json()
+            return None
                 
-                if response.status_code == 200:
-                    data = response.json()
-                    results[metric] = {
-                        "min_value": data.get("min_value"),
-                        "max_value": data.get("max_value"),
-                        "mean_value": data.get("mean_value"),
-                        "level": data.get("level"),
-                        "analysis": data.get("analysis"),
-                        "stress_score": data.get("stress_score"),
-                        "recommendations": data.get("recommendations", [])
+        except Exception as e:
+            logger.error(f"Heatmap fetch error for {metric}: {e}")
+            return None
+    
+    # =========================================================================
+    # DATA EXTRACTION HELPERS
+    # =========================================================================
+    
+    def _extract_sar_bands(self, data: Dict) -> Dict:
+        """Extract SAR band values."""
+        sar = data.get("sar_bands", {})
+        return {
+            "VV": sar.get("vv"),
+            "VH": sar.get("vh"),
+            "VV_VH_ratio": sar.get("ratio"),
+            "VV_trend": sar.get("vv_trend", "stable"),
+            "VH_trend": sar.get("vh_trend", "stable"),
+            "interpretation": self._interpret_sar(sar.get("vv"), sar.get("vh"))
+        }
+    
+    def _interpret_sar(self, vv: Optional[float], vh: Optional[float]) -> str:
+        """Interpret SAR band values."""
+        if vv is None:
+            return "no_data"
+        if vv > -8:
+            return "wet_soil_or_water"
+        elif vv > -12:
+            return "moist_soil"
+        elif vv > -16:
+            return "moderate_soil"
+        else:
+            return "dry_soil"
+    
+    def _extract_vegetation_indices(self, data: Dict) -> Dict:
+        """Extract and structure vegetation indices."""
+        veg = data.get("vegetation_indices", {})
+        
+        result = {}
+        for idx in ["ndvi", "evi", "ndre", "reci", "ndwi", "smi", "psri", "pri", "mcari"]:
+            if idx in veg:
+                val = veg[idx]
+                if isinstance(val, dict):
+                    result[idx.upper()] = {
+                        "current": val.get("mean"),
+                        "min": val.get("min"),
+                        "max": val.get("max"),
+                        "trend": val.get("trend"),
+                        "interpretation": self._interpret_index(idx, val.get("mean"))
+                    }
+                elif isinstance(val, (int, float)):
+                    result[idx.upper()] = {
+                        "current": val,
+                        "interpretation": self._interpret_index(idx, val)
                     }
-                    
-            except Exception as e:
-                logger.error(f"Heatmap fetch error for {metric}: {e}")
         
-        return results
+        # Add temporal trends if available
+        trends = data.get("temporal_trends", {})
+        if trends:
+            for idx, trend in trends.items():
+                if idx.upper() in result:
+                    result[idx.upper()]["trend_7d"] = trend.get("change_7d")
+                    result[idx.upper()]["trend_30d"] = trend.get("change_30d")
+        
+        return result
     
-    def format_for_llm(self, context: Dict[str, Any]) -> Dict[str, Any]:
-        """
-        Format aggregated context for LLM consumption.
-        Extracts key values and interpretations.
-        """
-        formatted = {
-            "field_info": context.get("field_info", {}),
+    def _interpret_index(self, index: str, value: Optional[float]) -> str:
+        """Interpret vegetation index value."""
+        if value is None:
+            return "no_data"
+        
+        index = index.lower()
+        
+        if index == "ndvi":
+            if value > 0.7: return "excellent_vegetation"
+            elif value > 0.5: return "healthy_vegetation"
+            elif value > 0.3: return "moderate_stress"
+            elif value > 0.1: return "severe_stress"
+            else: return "bare_soil_or_water"
+        
+        elif index == "ndre":
+            if value > 0.5: return "high_chlorophyll"
+            elif value > 0.3: return "adequate_chlorophyll"
+            elif value > 0.1: return "low_chlorophyll"
+            else: return "chlorophyll_deficiency"
+        
+        elif index == "smi":
+            if value > 0.6: return "adequate_moisture"
+            elif value > 0.4: return "moderate_moisture"
+            elif value > 0.2: return "low_moisture"
+            else: return "critical_moisture_deficit"
+        
+        elif index == "evi":
+            if value > 0.5: return "high_biomass"
+            elif value > 0.3: return "moderate_biomass"
+            else: return "low_biomass"
+        
+        elif index == "psri":
+            if value > 0.2: return "senescence_stress"
+            elif value > 0: return "mild_stress"
+            else: return "healthy"
+        
+        elif index == "pri":
+            if value > 0.05: return "high_photosynthetic_efficiency"
+            elif value > 0: return "moderate_efficiency"
+            else: return "photosynthetic_stress"
+        
+        return "unknown"
+    
+    def _extract_soil_indicators(self, data: Dict) -> Dict:
+        """Extract soil health indicators."""
+        soil = data.get("soil_indicators", {})
+        llm = data.get("llm_analysis", {})
+        
+        return {
+            "moisture": {
+                "level": llm.get("soil_moisture", {}).get("level", "unknown"),
+                "SMI_value": soil.get("smi"),
+                "status": llm.get("soil_moisture", {}).get("analysis", "")
+            },
+            "salinity": {
+                "level": llm.get("soil_salinity", {}).get("level", "unknown"),
+                "status": llm.get("soil_salinity", {}).get("analysis", "")
+            },
+            "organic_matter": {
+                "level": llm.get("organic_matter", {}).get("level", "unknown"),
+                "status": llm.get("organic_matter", {}).get("analysis", "")
+            },
+            "fertility": {
+                "level": llm.get("soil_fertility", {}).get("level", "unknown"),
+                "status": llm.get("soil_fertility", {}).get("analysis", "")
+            }
         }
+    
+    def _extract_clustering(self, data: Dict) -> Dict:
+        """Extract clustering/stress zone data."""
+        clustering = data.get("clustering", {})
+        stress = data.get("stress_detection", {})
         
-        # Vegetation indices
-        veg = context.get("vegetation_indices", {})
-        if veg:
-            formatted["vegetation_indices"] = {
-                "NDVI": {
-                    "current": veg.get("ndvi", {}).get("mean"),
-                    "min": veg.get("ndvi", {}).get("min"),
-                    "max": veg.get("ndvi", {}).get("max"),
-                    "interpretation": self._interpret_ndvi(veg.get("ndvi", {}).get("mean", 0))
-                },
-                "NDRE": {
-                    "current": veg.get("ndre", {}).get("mean"),
-                    "interpretation": self._interpret_ndre(veg.get("ndre", {}).get("mean", 0))
-                },
-                "EVI": {
-                    "current": veg.get("evi", {}).get("mean"),
-                },
-                "SMI": {
-                    "current": veg.get("smi", {}).get("mean"),
-                    "interpretation": self._interpret_smi(veg.get("smi", {}).get("mean", 0))
-                }
+        clusters = []
+        for cluster in clustering.get("clusters", []):
+            clusters.append({
+                "cluster_id": cluster.get("id"),
+                "num_patches": cluster.get("num_patches"),
+                "percentage": cluster.get("percentage"),
+                "stress_score_mean": cluster.get("stress_mean"),
+                "dominant_location": cluster.get("location")
+            })
+        
+        stressed_patches = []
+        for patch in stress.get("stressed_patches", []):
+            if patch.get("stress_score", 0) > 0.5:
+                stressed_patches.append(patch)
+        
+        return {
+            "clusters": clusters,
+            "stressed_patches": stressed_patches,
+            "overall_stress_score": stress.get("overall_stress", 0)
+        }
+    
+    def _extract_anomalies(self, data: Dict) -> Dict:
+        """Extract anomaly detection results."""
+        anomalies = data.get("anomaly_detection", {})
+        
+        return {
+            "total_detected": anomalies.get("total_anomalies", 0),
+            "percentage_affected": anomalies.get("anomaly_percentage", 0),
+            "high_priority": [
+                a for a in anomalies.get("anomaly_patches", [])
+                if a.get("stress_score", 0) > 0.7
+            ]
+        }
+    
+    def _extract_weather(self, data: Dict) -> Dict:
+        """Extract weather data."""
+        weather = data.get("weather_data", [])
+        
+        if not weather:
+            return {}
+        
+        # Aggregate last 7 days
+        recent = weather[:7] if len(weather) >= 7 else weather
+        
+        temps = [w.get("temp_max", 0) for w in recent if w.get("temp_max")]
+        precip = sum(w.get("precipitation", 0) for w in recent)
+        heat_days = sum(1 for w in recent if w.get("temp_max", 0) > 35)
+        dry_days = sum(1 for w in recent if w.get("precipitation", 0) == 0)
+        
+        return {
+            "recent_7d": {
+                "avg_temp_max": round(sum(temps) / len(temps), 1) if temps else None,
+                "heat_stress_days": heat_days,
+                "total_precipitation_mm": round(precip, 1),
+                "consecutive_dry_days": dry_days
+            },
+            "stress_indicators": {
+                "heat_stress": heat_days >= 3,
+                "drought_stress": dry_days >= 5 and precip < 10
             }
+        }
+    
+    # =========================================================================
+    # PRIORITY-BASED CONTEXT FORMATTING
+    # =========================================================================
+    
+    def format_for_priority(self, context: Dict, intent: str) -> Dict[str, Dict]:
+        """
+        Format context into priority levels based on intent.
         
-        # SAR bands
-        sar = context.get("sar_bands", {})
-        if sar:
-            formatted["sar_bands"] = {
-                "VV": sar.get("vv"),
-                "VH": sar.get("vh"),
-                "VV_VH_ratio": sar.get("ratio")
+        Returns:
+            {
+                "priority_1": {...},  # Primary evidence
+                "priority_2": {...},  # Supporting evidence
+                "priority_3": {...},  # Causal factors
+                "priority_4": {...}   # Validation
             }
+        """
+        veg = context.get("vegetation_indices", {})
+        sar = context.get("sar_bands", {})
+        soil = context.get("soil_indicators", {})
+        weather = self._extract_weather(context)
+        clustering = context.get("clustering", {})
+        anomalies = context.get("anomalies", {})
+        farmer = context.get("farmer_actions", {})
+        previous = context.get("previous_analysis", {})
         
-        # Health summary
-        health = context.get("health_summary", {})
-        if health:
-            formatted["health_summary"] = health
-        
-        # Stressed patches
-        stressed = context.get("stressed_patches", [])
-        if stressed:
-            formatted["stress_analysis"] = {
-                "stressed_patch_count": len(stressed),
-                "high_stress_patches": [p for p in stressed if p.get("stress_score", 0) > 0.7],
-                "affected_area_percent": sum(p.get("percentage", 0) for p in stressed)
+        # Default priority mapping
+        priority_1 = {
+            "NDVI": veg.get("NDVI"),
+            "EVI": veg.get("EVI"),
+            "NDRE": veg.get("NDRE"),
+            "RECI": veg.get("RECI"),
+            "temporal_trends": context.get("temporal_trends", {})
+        }
+        
+        priority_2 = {
+            "clustering": clustering,
+            "anomalies": anomalies,
+            "PSRI": veg.get("PSRI"),
+            "PRI": veg.get("PRI")
+        }
+        
+        priority_3 = {
+            "weather": weather,
+            "SMI": veg.get("SMI"),
+            "soil_indicators": soil,
+            "B05": context.get("sentinel2_bands", {}).get("B05"),
+            "B08": context.get("sentinel2_bands", {}).get("B08")
+        }
+        
+        priority_4 = {
+            "SAR": sar,
+            "previous_analysis": previous,
+            "farmer_actions": farmer
+        }
+        
+        # Adjust based on intent
+        if intent == "water_stress":
+            priority_1 = {
+                "SMI": veg.get("SMI"),
+                "NDWI": veg.get("NDWI"),
+                "SAR": sar,
+                "temporal_trends_SMI": context.get("temporal_trends", {}).get("SMI")
             }
+            priority_2["weather"] = weather
         
-        # Weather
-        weather = context.get("weather_data", [])
-        if weather:
-            latest = weather[0] if weather else {}
-            formatted["weather"] = {
-                "current": latest,
-                "recent_days": len(weather)
+        elif intent == "nutrient_status":
+            priority_1 = {
+                "NDRE": veg.get("NDRE"),
+                "RECI": veg.get("RECI"),
+                "MCARI": veg.get("MCARI"),
+                "B05": context.get("sentinel2_bands", {}).get("B05"),
+                "B06": context.get("sentinel2_bands", {}).get("B06")
             }
         
-        # LLM analysis from Sentinel-2
-        llm = context.get("llm_analysis", {})
-        if llm:
-            formatted["previous_analysis"] = {
-                "soil_moisture": llm.get("soil_moisture"),
-                "soil_fertility": llm.get("soil_fertility"),
-                "nitrogen_status": llm.get("nitrogen_status"),
-                "overall_health": llm.get("overall_health")
+        elif intent == "pest_disease":
+            priority_1 = {
+                "anomalies": anomalies,
+                "PSRI": veg.get("PSRI"),
+                "PRI": veg.get("PRI"),
+                "clustering_outliers": clustering.get("stressed_patches", [])
             }
         
-        return formatted
-    
-    def _interpret_ndvi(self, value: float) -> str:
-        if value is None:
-            return "unknown"
-        if value > 0.7:
-            return "excellent_vegetation"
-        elif value > 0.5:
-            return "healthy_vegetation"
-        elif value > 0.3:
-            return "moderate_stress"
-        elif value > 0.1:
-            return "severe_stress"
-        else:
-            return "bare_soil_or_water"
-    
-    def _interpret_ndre(self, value: float) -> str:
-        if value is None:
-            return "unknown"
-        if value > 0.5:
-            return "high_chlorophyll"
-        elif value > 0.3:
-            return "adequate_chlorophyll"
-        elif value > 0.1:
-            return "low_chlorophyll"
-        else:
-            return "chlorophyll_deficiency"
+        # Filter out None values
+        priority_1 = {k: v for k, v in priority_1.items() if v is not None}
+        priority_2 = {k: v for k, v in priority_2.items() if v is not None}
+        priority_3 = {k: v for k, v in priority_3.items() if v is not None}
+        priority_4 = {k: v for k, v in priority_4.items() if v is not None}
+        
+        return {
+            "priority_1": priority_1,
+            "priority_2": priority_2,
+            "priority_3": priority_3,
+            "priority_4": priority_4
+        }
     
-    def _interpret_smi(self, value: float) -> str:
-        if value is None:
-            return "unknown"
-        if value > 0.6:
-            return "adequate_moisture"
-        elif value > 0.4:
-            return "moderate_moisture"
-        elif value > 0.2:
-            return "low_moisture"
-        else:
-            return "critical_moisture_deficit"
+    def format_for_llm(self, context: Dict[str, Any]) -> Dict[str, Any]:
+        """
+        Format aggregated context for LLM consumption.
+        Backwards compatible version.
+        """
+        return {
+            "field_info": context.get("field_info", {}),
+            "vegetation_indices": context.get("vegetation_indices", {}),
+            "sar_bands": context.get("sar_bands", {}),
+            "health_summary": context.get("health_summary", {}),
+            "stress_analysis": {
+                "stressed_patch_count": len(context.get("stressed_patches", [])),
+                "high_stress_patches": [p for p in context.get("stressed_patches", []) 
+                                        if p.get("stress_score", 0) > 0.7]
+            },
+            "weather": self._extract_weather(context),
+            "soil_indicators": context.get("soil_indicators", {}),
+            "previous_analysis": context.get("llm_analysis", {})
+        }
 
 
-# Quick context fetch function
+# =============================================================================
+# QUICK FUNCTIONS
+# =============================================================================
+
 def fetch_field_context(
     coordinates: Dict[str, Any],
     crop_type: str = "Wheat",
     area_acres: float = 1.0,
-    fetch_satellite: bool = True
+    fetch_satellite: bool = True,
+    farmer_context: Optional[Dict] = None
 ) -> Dict[str, Any]:
     """
     Quick function to fetch and format field context.
@@ -341,7 +535,8 @@ def fetch_field_context(
         coordinates: {"center_lat": float, "center_lon": float, "bbox": [...]}
         crop_type: Crop type string
         area_acres: Field size
-        fetch_satellite: Whether to fetch from HF APIs (set False for quick response)
+        fetch_satellite: Whether to fetch from HF APIs
+        farmer_context: Optional farmer data
     """
     aggregator = ContextAggregator()
     
@@ -349,7 +544,8 @@ def fetch_field_context(
         raw_context = aggregator.fetch_full_context(
             coordinates=coordinates,
             crop_type=crop_type,
-            area_acres=area_acres
+            area_acres=area_acres,
+            farmer_context=farmer_context
         )
         return aggregator.format_for_llm(raw_context)
     else:
@@ -360,3 +556,33 @@ def fetch_field_context(
                 "coordinates": coordinates
             }
         }
+
+
+def fetch_priority_context(
+    coordinates: Dict[str, Any],
+    crop_type: str,
+    area_acres: float,
+    intent: str,
+    farmer_context: Optional[Dict] = None
+) -> Dict[str, Dict]:
+    """
+    Fetch satellite context and organize by priority for intent.
+    
+    Returns:
+        {
+            "priority_1": {...},
+            "priority_2": {...},
+            "priority_3": {...},
+            "priority_4": {...}
+        }
+    """
+    aggregator = ContextAggregator()
+    
+    raw_context = aggregator.fetch_full_context(
+        coordinates=coordinates,
+        crop_type=crop_type,
+        area_acres=area_acres,
+        farmer_context=farmer_context
+    )
+    
+    return aggregator.format_for_priority(raw_context, intent)

intent_classifier.py

@@ -1,66 +1,166 @@
 """
 Intent Classifier for Agricultural Chatbot
 ==========================================
-Detects user intent to determine context priority.
+Detects user intent with sub-intents for priority context selection.
+Matching Developer Specification categories.
 """
 
 from typing import Dict, List, Tuple
 import re
 
-# Intent categories with keywords
+# =============================================================================
+# INTENT PATTERNS - Based on Developer Spec
+# =============================================================================
+
 INTENT_PATTERNS = {
     "vegetation_health": {
-        "keywords": ["yellow", "yellowing", "brown", "dying", "wilting", "healthy", "health",
-                     "crop health", "plant health", "leaf", "leaves", "chlorophyll", "green"],
-        "sub_intents": ["chlorophyll_issue", "nutrient_deficiency", "general_health"]
+        "keywords": [
+            "yellow", "yellowing", "brown", "browning", "dying", "wilting", 
+            "healthy", "health", "crop health", "plant health", "leaf", "leaves",
+            "chlorophyll", "green", "greenness", "stunted", "weak", "pale",
+            "ndvi", "evi", "vegetation", "biomass", "vigor", "canopy"
+        ],
+        "phrases": [
+            "why is my crop", "is my crop healthy", "crop looks", 
+            "plants look", "leaves turning", "plant dying"
+        ],
+        "sub_intents": ["chlorophyll_issue", "nutrient_deficiency", "general_health"],
+        "priority": 1
     },
+    
     "water_stress": {
-        "keywords": ["water", "irrigation", "irrigate", "dry", "drought", "moisture", 
-                     "thirsty", "watering", "rain", "wet"],
-        "sub_intents": ["drought_stress", "overwatering", "irrigation_timing"]
+        "keywords": [
+            "water", "irrigation", "irrigate", "dry", "drought", "moisture",
+            "thirsty", "watering", "rain", "wet", "smi", "ndwi", "soil moisture",
+            "dehydrated", "wilt", "drooping", "crispy", "parched"
+        ],
+        "phrases": [
+            "need water", "should i water", "need irrigation", "drought stress",
+            "when to irrigate", "soil is dry", "field is dry"
+        ],
+        "sub_intents": ["drought_stress", "overwatering", "irrigation_timing"],
+        "priority": 2
     },
+    
     "nutrient_status": {
-        "keywords": ["fertilizer", "nutrient", "nitrogen", "phosphorus", "potassium",
-                     "npk", "deficiency", "feeding", "feed"],
-        "sub_intents": ["nitrogen_deficiency", "nutrient_excess", "fertilizer_timing"]
+        "keywords": [
+            "fertilizer", "nutrient", "nitrogen", "phosphorus", "potassium",
+            "npk", "deficiency", "feeding", "feed", "ndre", "reci", "mcari",
+            "urea", "dap", "mop", "manure", "compost", "micronutrient"
+        ],
+        "phrases": [
+            "need fertilizer", "nutrient deficiency", "should i fertilize",
+            "lacking nutrients", "nitrogen deficiency", "fertilizer amount"
+        ],
+        "sub_intents": ["nitrogen_deficiency", "nutrient_excess", "fertilizer_timing"],
+        "priority": 3
     },
+    
     "pest_disease": {
-        "keywords": ["pest", "disease", "insect", "bug", "infection", "fungus",
-                     "blight", "rot", "spots", "holes", "eating"],
-        "sub_intents": ["pest_damage", "fungal_disease", "bacterial_issue"]
-    },
-    "forecast_query": {
-        "keywords": ["forecast", "predict", "future", "next week", "tomorrow",
-                     "will", "expect", "trend", "coming days"],
-        "sub_intents": ["growth_forecast", "stress_prediction", "weather_impact"]
+        "keywords": [
+            "pest", "disease", "insect", "bug", "infection", "fungus",
+            "blight", "rot", "spots", "holes", "eating", "aphid", "borer",
+            "rust", "mildew", "virus", "bacteria", "infestation", "damage"
+        ],
+        "phrases": [
+            "pest attack", "disease problem", "insect damage", "fungal infection",
+            "what is eating", "spots on leaves", "pest risk"
+        ],
+        "sub_intents": ["pest_damage", "fungal_disease", "bacterial_issue", "viral_disease"],
+        "priority": 4
     },
+    
     "zone_specific": {
-        "keywords": ["area", "zone", "patch", "section", "part", "corner",
-                     "northeast", "northwest", "southeast", "southwest", "north", "south"],
-        "sub_intents": ["zone_diagnosis", "zone_comparison"]
+        "keywords": [
+            "area", "zone", "patch", "section", "part", "corner", "side",
+            "northeast", "northwest", "southeast", "southwest", "north", "south",
+            "east", "west", "center", "edge", "boundary", "specific"
+        ],
+        "phrases": [
+            "which area", "which zone", "which part", "where is the problem",
+            "affected area", "problem zone", "specific area"
+        ],
+        "sub_intents": ["zone_diagnosis", "zone_comparison", "spatial_query"],
+        "priority": 5
     },
+    
+    "forecast_query": {
+        "keywords": [
+            "forecast", "predict", "prediction", "future", "next week", "tomorrow",
+            "will", "expect", "trend", "coming days", "upcoming", "projection",
+            "growth", "yield", "estimate", "outlook"
+        ],
+        "phrases": [
+            "what will happen", "next week", "in the future", "will my crop",
+            "expected yield", "growth forecast", "weather forecast"
+        ],
+        "sub_intents": ["growth_forecast", "stress_prediction", "weather_impact", "yield_forecast"],
+        "priority": 6
+    },
+    
     "action_recommendation": {
-        "keywords": ["what should", "how to", "fix", "solve", "recommend", "advice",
-                     "help", "do", "action", "steps", "treatment"],
-        "sub_intents": ["immediate_action", "long_term_plan"]
+        "keywords": [
+            "what should", "how to", "fix", "solve", "recommend", "advice",
+            "help", "do", "action", "steps", "treatment", "remedy", "solution",
+            "best practice", "suggestion", "improve"
+        ],
+        "phrases": [
+            "what should i do", "how do i fix", "how to solve", "recommend",
+            "give me advice", "best action", "immediate action"
+        ],
+        "sub_intents": ["immediate_action", "long_term_plan", "preventive_action"],
+        "priority": 7
     },
+    
     "comparison": {
-        "keywords": ["compare", "better", "worse", "change", "changed", "difference",
-                     "last week", "before", "improvement", "decline"],
-        "sub_intents": ["temporal_comparison", "zone_comparison"]
+        "keywords": [
+            "compare", "comparison", "better", "worse", "change", "changed", 
+            "difference", "last week", "before", "improvement", "decline",
+            "progress", "regression", "historical", "trend"
+        ],
+        "phrases": [
+            "compared to", "better than", "worse than", "has it improved",
+            "how has it changed", "over time", "last month"
+        ],
+        "sub_intents": ["temporal_comparison", "zone_comparison", "historical_analysis"],
+        "priority": 8
     },
+    
     "general_query": {
-        "keywords": ["what", "how", "why", "tell", "about", "explain"],
-        "sub_intents": ["general_info"]
+        "keywords": [
+            "what", "how", "why", "tell", "about", "explain", "hello", "hi",
+            "information", "details", "overview", "status", "summary"
+        ],
+        "phrases": [
+            "tell me about", "what is", "how does", "explain"
+        ],
+        "sub_intents": ["general_info"],
+        "priority": 9
     }
 }
 
+# Hindi/regional language keywords (common agricultural terms)
+REGIONAL_KEYWORDS = {
+    "vegetation_health": ["पीला", "पत्ते", "सूखा", "मुरझाना"],
+    "water_stress": ["पानी", "सिंचाई", "सूखा"],
+    "nutrient_status": ["खाद", "यूरिया", "उर्वरक"],
+    "pest_disease": ["कीट", "रोग", "कीड़ा"]
+}
+
+
+# =============================================================================
+# INTENT CLASSIFIER
+# =============================================================================
 
 class IntentClassifier:
-    """Classifies user queries into agricultural intent categories."""
+    """
+    Classifies user queries into agricultural intent categories.
+    Uses keyword matching, phrase matching, and confidence scoring.
+    """
     
     def __init__(self):
         self.patterns = INTENT_PATTERNS
+        self.regional = REGIONAL_KEYWORDS
     
     def classify(self, query: str) -> Dict:
         """
@@ -70,41 +170,37 @@ class IntentClassifier:
             {
                 "primary_intent": str,
                 "sub_intents": List[str],
-                "confidence": float,
-                "matched_keywords": List[str]
+                "confidence": float (0.0-1.0),
+                "matched_keywords": List[str],
+                "all_intents": List[Tuple[str, float]]  # All detected intents with scores
             }
         """
         query_lower = query.lower()
         intent_scores = {}
         matched_keywords = {}
         
-        # Score each intent based on keyword matches
+        # Score each intent
         for intent, config in self.patterns.items():
-            keywords = config["keywords"]
-            matches = [kw for kw in keywords if kw in query_lower]
+            score, matches = self._score_intent(query_lower, config)
             
-            if matches:
-                # Score based on number and specificity of matches
-                score = len(matches) * 0.2
-                # Boost for longer, more specific matches
-                for match in matches:
-                    score += len(match) * 0.01
-                
+            # Also check regional keywords
+            if intent in self.regional:
+                for kw in self.regional[intent]:
+                    if kw in query:
+                        score += 0.3
+                        matches.append(kw)
+            
+            if score > 0:
                 intent_scores[intent] = min(score, 1.0)
                 matched_keywords[intent] = matches
         
         if not intent_scores:
-            # Default to general query
-            return {
-                "primary_intent": "general_query",
-                "sub_intents": ["general_info"],
-                "confidence": 0.5,
-                "matched_keywords": []
-            }
+            return self._default_response()
         
-        # Get highest scoring intent
-        primary_intent = max(intent_scores, key=intent_scores.get)
-        confidence = intent_scores[primary_intent]
+        # Sort intents by score
+        sorted_intents = sorted(intent_scores.items(), key=lambda x: x[1], reverse=True)
+        primary_intent = sorted_intents[0][0]
+        confidence = sorted_intents[0][1]
         
         # Get sub-intents
         sub_intents = self._detect_sub_intents(query_lower, primary_intent)
@@ -113,26 +209,74 @@ class IntentClassifier:
             "primary_intent": primary_intent,
             "sub_intents": sub_intents,
             "confidence": round(confidence, 2),
-            "matched_keywords": matched_keywords.get(primary_intent, [])
+            "matched_keywords": matched_keywords.get(primary_intent, []),
+            "all_intents": [(intent, round(score, 2)) for intent, score in sorted_intents[:3]]
         }
     
+    def _score_intent(self, query: str, config: Dict) -> Tuple[float, List[str]]:
+        """Calculate score for a single intent."""
+        score = 0.0
+        matches = []
+        
+        keywords = config.get("keywords", [])
+        phrases = config.get("phrases", [])
+        
+        # Check keyword matches
+        for kw in keywords:
+            if kw in query:
+                score += 0.15
+                matches.append(kw)
+                # Bonus for exact word match (not substring)
+                if re.search(rf'\b{re.escape(kw)}\b', query):
+                    score += 0.05
+        
+        # Check phrase matches (higher score)
+        for phrase in phrases:
+            if phrase in query:
+                score += 0.35
+                matches.append(phrase)
+        
+        # Boost for multiple matches
+        if len(matches) >= 3:
+            score += 0.1
+        
+        return score, matches
+    
     def _detect_sub_intents(self, query: str, primary_intent: str) -> List[str]:
         """Detect more specific sub-intents within the primary intent."""
         sub_intents = []
         config = self.patterns.get(primary_intent, {})
         
-        # Add base sub-intents
+        # Add base sub-intent
         if config.get("sub_intents"):
             sub_intents.append(config["sub_intents"][0])
         
-        # Detect additional context
+        # Detect question type
         if "why" in query:
             sub_intents.append("causal_analysis")
-        if "how much" in query or "how many" in query:
+        if "how much" in query or "how many" in query or "quantity" in query:
             sub_intents.append("quantitative")
         if "when" in query:
             sub_intents.append("temporal")
         if "where" in query:
             sub_intents.append("spatial")
+        if "should" in query or "recommend" in query:
+            sub_intents.append("recommendation_needed")
+        if "urgent" in query or "immediately" in query or "emergency" in query:
+            sub_intents.append("urgent")
         
         return sub_intents if sub_intents else ["general"]
+    
+    def _default_response(self) -> Dict:
+        """Return default classification for unrecognized queries."""
+        return {
+            "primary_intent": "general_query",
+            "sub_intents": ["general_info"],
+            "confidence": 0.4,
+            "matched_keywords": [],
+            "all_intents": [("general_query", 0.4)]
+        }
+    
+    def get_priority_for_intent(self, intent: str) -> int:
+        """Get priority number for an intent."""
+        return self.patterns.get(intent, {}).get("priority", 9)

models.py

@@ -0,0 +1,308 @@
+"""
+Pydantic Models for Agricultural Chatbot
+=========================================
+Structured data models matching the Developer Specification.
+"""
+
+from pydantic import BaseModel, Field
+from typing import Optional, List, Dict, Any
+from datetime import datetime
+
+
+# =============================================================================
+# VEGETATION INDICES MODELS
+# =============================================================================
+
+class IndexValue(BaseModel):
+    """Single vegetation index with value and interpretation."""
+    current: Optional[float] = None
+    trend_7d: Optional[float] = None
+    trend_30d: Optional[float] = None
+    min: Optional[float] = None
+    max: Optional[float] = None
+    interpretation: Optional[str] = None
+    zone_values: Optional[Dict[str, float]] = None  # NW, NE, SW, SE
+
+
+class VegetationIndices(BaseModel):
+    """Complete vegetation indices data."""
+    NDVI: Optional[IndexValue] = None
+    EVI: Optional[IndexValue] = None
+    NDRE: Optional[IndexValue] = None
+    RECI: Optional[IndexValue] = None
+    NDWI: Optional[IndexValue] = None
+    SMI: Optional[IndexValue] = None
+    PSRI: Optional[IndexValue] = None
+    PRI: Optional[IndexValue] = None
+    MCARI: Optional[IndexValue] = None
+    SOMI: Optional[IndexValue] = None
+    SFI: Optional[IndexValue] = None
+
+
+# =============================================================================
+# SAR DATA MODELS
+# =============================================================================
+
+class SARBands(BaseModel):
+    """SAR band data from Sentinel-1."""
+    VV: Optional[float] = None
+    VH: Optional[float] = None
+    VV_VH_ratio: Optional[float] = None
+    VV_trend: Optional[str] = None  # "increasing", "decreasing", "stable"
+    VH_trend: Optional[str] = None
+    interpretation: Optional[str] = None
+
+
+# =============================================================================
+# CLUSTERING/STRESS MODELS
+# =============================================================================
+
+class ClusterStats(BaseModel):
+    """Statistics for a stress cluster."""
+    cluster_id: int
+    num_patches: int
+    percentage: float  # % of field
+    stress_score_mean: float
+    stress_score_std: Optional[float] = None
+    dominant_location: Optional[str] = None  # "northeast", "southwest", etc.
+    spectral_signature: Optional[Dict[str, float]] = None
+
+
+class AnomalyPatch(BaseModel):
+    """Detected anomaly patch."""
+    patch_id: int
+    location: Optional[str] = None
+    anomaly_type: str  # "spectral_outlier", "temporal_anomaly", etc.
+    stress_score: float
+    coordinates: Optional[List[float]] = None
+
+
+class ClusteringData(BaseModel):
+    """All clustering and anomaly data."""
+    clusters: List[ClusterStats] = []
+    stressed_clusters: List[ClusterStats] = []
+    anomalies_detected: int = 0
+    anomaly_patches: List[AnomalyPatch] = []
+
+
+# =============================================================================
+# WEATHER MODELS
+# =============================================================================
+
+class WeatherData(BaseModel):
+    """Weather information."""
+    avg_temp_max: Optional[float] = None
+    avg_temp_min: Optional[float] = None
+    heat_stress_days: Optional[int] = None
+    total_precipitation_mm: Optional[float] = None
+    avg_humidity: Optional[float] = None
+    consecutive_dry_days: Optional[int] = None
+    heat_stress: bool = False
+    drought_stress: bool = False
+
+
+class WeatherForecast(BaseModel):
+    """Weather forecast data."""
+    rain_expected: bool = False
+    rain_mm: Optional[float] = None
+    temperature_trend: Optional[str] = None
+
+
+# =============================================================================
+# FARMER CONTEXT MODELS
+# =============================================================================
+
+class FarmerActions(BaseModel):
+    """Farmer's recent actions."""
+    last_irrigation: Optional[str] = None  # ISO date
+    days_since_irrigation: Optional[int] = None
+    last_fertilizer: Optional[str] = None
+    days_since_fertilizer: Optional[int] = None
+    last_spraying: Optional[str] = None
+    notes: List[str] = []
+
+
+class FarmerProfile(BaseModel):
+    """Farmer profile information."""
+    role: Optional[str] = None
+    years_farming: Optional[int] = None
+    irrigation_method: Optional[str] = None
+    farming_goal: Optional[str] = None
+
+
+# =============================================================================
+# PRIORITY CONTEXT MODELS
+# =============================================================================
+
+class Priority1Context(BaseModel):
+    """Primary evidence - most diagnostic data."""
+    NDVI: Optional[Dict] = None
+    EVI: Optional[Dict] = None
+    NDRE: Optional[Dict] = None
+    RECI: Optional[Dict] = None
+    temporal_trends: Optional[Dict] = None
+
+
+class Priority2Context(BaseModel):
+    """Supporting evidence - clusters, anomalies."""
+    clustering: Optional[Dict] = None
+    anomalies: Optional[Dict] = None
+    PSRI: Optional[Dict] = None
+
+
+class Priority3Context(BaseModel):
+    """Causal factors - weather, soil, bands."""
+    weather: Optional[Dict] = None
+    SMI: Optional[Dict] = None
+    band_values: Optional[Dict] = None
+
+
+class Priority4Context(BaseModel):
+    """Validation - SAR, previous analysis, farmer actions."""
+    SAR: Optional[Dict] = None
+    previous_analysis: Optional[Dict] = None
+    farmer_actions: Optional[Dict] = None
+
+
+# =============================================================================
+# REASONING STAGE MODELS
+# =============================================================================
+
+class ClaimStage(BaseModel):
+    """Stage 3A: Initial claim output."""
+    initial_claim: str
+    hypothesis: str
+    evidence_cited: List[str] = []
+    confidence: float
+    uncertainties: List[str] = []
+
+
+class ValidateStage(BaseModel):
+    """Stage 3B: Validation output."""
+    validation_result: str  # "confirmed", "weakened", "neutral"
+    confidence_updated: float
+    spatial_notes: Optional[str] = None
+    new_evidence_summary: Optional[str] = None
+
+
+class ContradictStage(BaseModel):
+    """Stage 3C: Contradiction output."""
+    contradiction_found: bool
+    contradicting_evidence: List[str] = []
+    alternative_hypothesis: Optional[str] = None
+    alternative_confidence: float = 0.0
+    reasoning: Optional[str] = None
+
+
+class ConfirmStage(BaseModel):
+    """Stage 3D: Confirmation output."""
+    final_diagnosis: str
+    confidence: float
+    causal_chain: Optional[str] = None
+    root_cause: Optional[str] = None
+    symptoms: List[str] = []
+    evidence_summary: Optional[Dict[str, List[str]]] = None
+    recommendation: Optional[str] = None
+
+
+# =============================================================================
+# REASONING TRACE MODELS
+# =============================================================================
+
+class StageTrace(BaseModel):
+    """Trace for a single reasoning stage."""
+    hypothesis: Optional[str] = None
+    result: Optional[str] = None
+    found: Optional[bool] = None
+    alternative: Optional[str] = None
+    final: Optional[str] = None
+    confidence: float
+    context_used: List[str]
+
+
+class ReasoningTrace(BaseModel):
+    """Complete reasoning trace for transparency."""
+    intent_detected: str
+    intent_confidence: float
+    sub_intents: List[str]
+    stages: Dict[str, StageTrace]
+    causal_chain: Optional[str] = None
+    evidence_summary: Dict[str, List[str]]
+
+
+class ContextPriorityUsed(BaseModel):
+    """Which context was used at each priority level."""
+    priority_1: List[str] = []
+    priority_2: List[str] = []
+    priority_3: List[str] = []
+    priority_4: List[str] = []
+
+
+# =============================================================================
+# API REQUEST/RESPONSE MODELS
+# =============================================================================
+
+class ChatRequest(BaseModel):
+    """Chat request from Flutter app."""
+    session_id: str
+    message: str
+    user_id: Optional[str] = None
+    field_context: Optional[Dict[str, Any]] = None
+    field_name: Optional[str] = None  # Optional specific field
+
+
+class ResponseContent(BaseModel):
+    """Main response content."""
+    message: str
+    confidence: float
+    diagnosis: Optional[str] = None
+
+
+class ChatResponse(BaseModel):
+    """Full chat response matching spec."""
+    response: ResponseContent
+    session_id: str
+    message_id: str
+    timestamp: str
+    reasoning_trace: Optional[ReasoningTrace] = None
+    context_priority_used: Optional[ContextPriorityUsed] = None
+    suggested_followups: List[str] = []
+
+
+# =============================================================================
+# FULL SATELLITE CONTEXT
+# =============================================================================
+
+class FullSatelliteContext(BaseModel):
+    """Complete satellite context for reasoning."""
+    field_info: Dict[str, Any] = {}
+    vegetation_indices: Optional[VegetationIndices] = None
+    sar_bands: Optional[SARBands] = None
+    clustering: Optional[ClusteringData] = None
+    weather: Optional[WeatherData] = None
+    weather_forecast: Optional[WeatherForecast] = None
+    farmer_actions: Optional[FarmerActions] = None
+    previous_analysis: Optional[Dict[str, Any]] = None
+    temporal_trends: Optional[Dict[str, Any]] = None
+    band_values: Optional[Dict[str, float]] = None
+
+
+# =============================================================================
+# HELPER FUNCTIONS
+# =============================================================================
+
+def create_empty_response(session_id: str, message: str = "Unable to process") -> ChatResponse:
+    """Create a fallback empty response."""
+    return ChatResponse(
+        response=ResponseContent(
+            message=message,
+            confidence=0.0,
+            diagnosis=None
+        ),
+        session_id=session_id,
+        message_id="",
+        timestamp=datetime.now().isoformat(),
+        reasoning_trace=None,
+        context_priority_used=None,
+        suggested_followups=[]
+    )

priority_mapper.py

@@ -2,71 +2,90 @@
 Priority Context Mapper for Agricultural Chatbot
 =================================================
 Maps detected intents to prioritized context selection.
+Following Developer Specification exactly.
 """
 
 from typing import Dict, List, Any, Optional
 
-# Intent to Context Priority Mapping
+# =============================================================================
+# INTENT TO CONTEXT PRIORITY MAPPING (From Developer Spec)
+# =============================================================================
+
 INTENT_CONTEXT_PRIORITIES = {
     "vegetation_health": {
         "priority_1": ["NDVI", "EVI", "NDRE", "RECI", "temporal_trends.NDVI"],
-        "priority_2": ["clustering.stressed_patches", "anomalies", "PSRI"],
-        "priority_3": ["weather.temperature", "SMI", "B05", "B08"],
-        "priority_4": ["SAR.VV", "previous_analysis", "farmer_actions"]
+        "priority_2": ["clustering.stressed_patches", "anomalies", "PSRI", "PRI"],
+        "priority_3": ["weather.temperature", "SMI", "B05", "B08", "weather.heat_stress"],
+        "priority_4": ["SAR.VV", "SAR.VH", "previous_analysis", "farmer_actions"]
     },
+    
     "water_stress": {
-        "priority_1": ["SMI", "NDWI", "SAR.VV", "SAR.VH"],
+        "priority_1": ["SMI", "NDWI", "SAR.VV", "SAR.VH", "soil_indicators.moisture"],
         "priority_2": ["temporal_trends.SMI", "weather.precipitation", "weather.evapotranspiration"],
-        "priority_3": ["NDVI", "clustering.moisture_clusters", "B11", "B12"],
+        "priority_3": ["NDVI", "clustering.moisture_clusters", "B11", "B12", "sentinel2_bands.B11"],
         "priority_4": ["farmer_actions.irrigation", "forecast.rain", "previous_analysis"]
     },
+    
     "nutrient_status": {
-        "priority_1": ["NDRE", "RECI", "MCARI", "B05", "B06", "B07"],
+        "priority_1": ["NDRE", "RECI", "MCARI", "B05", "B06", "B07", "sentinel2_bands.B05"],
         "priority_2": ["NDVI", "EVI", "temporal_trends.NDRE"],
-        "priority_3": ["SMI", "SFI", "clustering.nutrient_clusters"],
+        "priority_3": ["SMI", "SFI", "SOMI", "clustering.nutrient_clusters", "soil_indicators.fertility"],
         "priority_4": ["farmer_actions.fertilizer", "weather", "previous_analysis"]
     },
+    
     "pest_disease": {
-        "priority_1": ["anomalies", "PSRI", "PRI", "spatial_patterns.hotspots"],
-        "priority_2": ["NDVI", "temporal_trends.sudden_changes", "clustering.outliers"],
-        "priority_3": ["weather.humidity", "B04", "B05"],
+        "priority_1": ["anomalies", "PSRI", "PRI", "spatial_patterns.hotspots", "clustering.outliers"],
+        "priority_2": ["NDVI", "temporal_trends.sudden_changes", "clustering.stressed_patches"],
+        "priority_3": ["weather.humidity", "weather.temperature", "B04", "B05"],
         "priority_4": ["farmer_actions.spraying", "previous_analysis", "historical_issues"]
     },
+    
     "zone_specific": {
-        "priority_1": ["clustering.zone_stats", "patch_assignments", "spatial_embeddings"],
-        "priority_2": ["anomalies.in_zone", "all_indices.zone_values"],
-        "priority_3": ["temporal_trends.zone_specific"],
+        "priority_1": ["clustering.zone_stats", "patch_assignments", "spatial_embeddings", "clustering.clusters"],
+        "priority_2": ["anomalies.in_zone", "vegetation_indices", "all_indices.zone_values"],
+        "priority_3": ["temporal_trends.zone_specific", "temporal_trends"],
         "priority_4": ["previous_analysis.zone_notes", "farmer_actions.zone_specific"]
     },
+    
     "forecast_query": {
-        "priority_1": ["forecast.predictions", "temporal_trends.all", "weather.forecast"],
-        "priority_2": ["NDVI", "SMI", "current_stress_level"],
-        "priority_3": ["historical_patterns", "growth_stage"],
+        "priority_1": ["forecast.predictions", "temporal_trends", "weather.forecast", "weather_data"],
+        "priority_2": ["NDVI", "SMI", "current_stress_level", "health_summary"],
+        "priority_3": ["historical_patterns", "growth_stage", "clustering"],
         "priority_4": ["farmer_actions.planned", "previous_analysis"]
     },
+    
     "action_recommendation": {
-        "priority_1": ["stress_summary", "NDVI", "SMI", "anomalies"],
-        "priority_2": ["weather.current", "weather.forecast"],
-        "priority_3": ["clustering.priority_zones", "temporal_trends"],
+        "priority_1": ["health_summary", "NDVI", "SMI", "anomalies", "stressed_patches"],
+        "priority_2": ["weather", "weather.forecast", "clustering.priority_zones"],
+        "priority_3": ["temporal_trends", "soil_indicators"],
         "priority_4": ["farmer_actions", "previous_analysis", "recommendations_history"]
     },
+    
     "comparison": {
-        "priority_1": ["temporal_trends.all", "historical.NDVI", "historical.SMI"],
+        "priority_1": ["temporal_trends", "historical.NDVI", "historical.SMI"],
         "priority_2": ["change_detection", "improvement_metrics"],
         "priority_3": ["weather.historical", "farmer_actions.historical"],
         "priority_4": ["previous_analysis", "baseline_values"]
     },
+    
     "general_query": {
-        "priority_1": ["NDVI", "stress_summary", "weather.current"],
-        "priority_2": ["SMI", "anomalies", "clustering.summary"],
-        "priority_3": ["temporal_trends", "forecast"],
+        "priority_1": ["NDVI", "health_summary", "weather", "field_info"],
+        "priority_2": ["SMI", "anomalies", "clustering.summary", "vegetation_indices"],
+        "priority_3": ["temporal_trends", "forecast", "soil_indicators"],
         "priority_4": ["farmer_actions", "previous_analysis"]
     }
 }
 
 
+# =============================================================================
+# PRIORITY CONTEXT MAPPER
+# =============================================================================
+
 class PriorityContextMapper:
-    """Maps intents to prioritized context for selective retrieval."""
+    """
+    Maps intents to prioritized context for selective retrieval.
+    Key principle: NOT all context at once - priority-based selection.
+    """
     
     def __init__(self):
         self.priority_map = INTENT_CONTEXT_PRIORITIES
@@ -86,7 +105,7 @@ class PriorityContextMapper:
         
         Args:
             intent: Detected intent
-            full_context: Complete context data
+            full_context: Complete context data from aggregator
             priority_levels: Which priority levels to include
             
         Returns:
@@ -120,7 +139,7 @@ class PriorityContextMapper:
         for path in field_paths:
             value = self._get_nested_value(context, path)
             if value is not None:
-                # Use last part of path as key for simplicity
+                # Use last part of path as key
                 key = path.split(".")[-1]
                 extracted[key] = value
         
@@ -128,12 +147,24 @@ class PriorityContextMapper:
     
     def _get_nested_value(self, data: Dict, path: str) -> Any:
         """Get nested value using dot notation (e.g., 'weather.temperature')."""
+        if not data or not path:
+            return None
+        
         keys = path.split(".")
         current = data
         
         for key in keys:
-            if isinstance(current, dict) and key in current:
-                current = current[key]
+            if isinstance(current, dict):
+                # Try exact match first
+                if key in current:
+                    current = current[key]
+                # Try case-insensitive match
+                elif key.upper() in current:
+                    current = current[key.upper()]
+                elif key.lower() in current:
+                    current = current[key.lower()]
+                else:
+                    return None
             else:
                 return None
         
@@ -149,17 +180,70 @@ class PriorityContextMapper:
         
         Returns:
             {
-                "claim_context": {...},      # Priority 1
-                "validate_context": {...},   # Priority 2
-                "contradict_context": {...}, # Priority 3
-                "confirm_context": {...}     # Priority 4
+                "claim_context": {...},      # Priority 1 - for initial hypothesis
+                "validate_context": {...},   # Priority 2 - supporting evidence
+                "contradict_context": {...}, # Priority 3 - causal factors
+                "confirm_context": {...}     # Priority 4 - validation
             }
         """
         priority_context = self.extract_priority_context(intent, full_context)
         
+        # Also add full vegetation indices if available for easier access
+        veg = full_context.get("vegetation_indices", {})
+        
+        claim = priority_context.get("priority_1", {})
+        validate = priority_context.get("priority_2", {})
+        contradict = priority_context.get("priority_3", {})
+        confirm = priority_context.get("priority_4", {})
+        
+        # Enrich with direct index access if not already present
+        if veg:
+            for idx in ["NDVI", "EVI", "NDRE", "SMI", "NDWI"]:
+                if idx in veg and idx not in claim:
+                    claim[idx] = veg[idx]
+        
+        # Add field info to claim context
+        field_info = full_context.get("field_info", {})
+        if field_info:
+            claim["crop_type"] = field_info.get("crop_type")
+            claim["area_acres"] = field_info.get("area_acres")
+        
+        # Add SAR data to confirm context
+        sar = full_context.get("sar_bands", {})
+        if sar and "VV" not in confirm:
+            confirm["SAR"] = sar
+        
+        # Add farmer actions if available
+        farmer = full_context.get("farmer_actions", {})
+        if farmer:
+            confirm["farmer_actions"] = farmer
+        
+        # Add previous analysis
+        prev = full_context.get("previous_analysis", {})
+        if prev:
+            confirm["previous_analysis"] = prev
+        
         return {
-            "claim_context": priority_context.get("priority_1", {}),
-            "validate_context": priority_context.get("priority_2", {}),
-            "contradict_context": priority_context.get("priority_3", {}),
-            "confirm_context": priority_context.get("priority_4", {})
+            "claim_context": claim,
+            "validate_context": validate,
+            "contradict_context": contradict,
+            "confirm_context": confirm
         }
+    
+    def get_context_for_stage(
+        self,
+        stage: str,
+        intent: str,
+        full_context: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """Get context for a specific reasoning stage."""
+        staged = self.build_staged_context(intent, full_context)
+        
+        stage_map = {
+            "claim": "claim_context",
+            "validate": "validate_context", 
+            "contradict": "contradict_context",
+            "confirm": "confirm_context"
+        }
+        
+        return staged.get(stage_map.get(stage, "claim_context"), {})

prompts.py

@@ -2,129 +2,154 @@
 LLM Prompts for Multi-Stage Reasoning
 ======================================
 Prompts for each stage: Claim → Validate → Contradict → Confirm
+Following the Developer Specification exactly.
 """
 
 # =============================================================================
 # SYSTEM PROMPT (Base context)
 # =============================================================================
 
-SYSTEM_PROMPT = """You are AGROW AI, an expert agricultural advisor for farmers in India.
+SYSTEM_PROMPT = """You are AGROW AI, an expert agricultural advisor for Indian farmers.
 
-You specialize in:
-- Satellite imagery interpretation (Sentinel-2, SAR data)
-- Vegetation indices analysis (NDVI, NDRE, EVI, SMI, etc.)
-- Crop stress diagnosis (water, nutrient, pest/disease)
+SPECIALIZATIONS:
+- Satellite imagery interpretation (Sentinel-1 SAR, Sentinel-2 optical bands)
+- Vegetation indices analysis (NDVI, NDRE, EVI, SMI, PSRI, PRI, MCARI, etc.)
+- Crop stress diagnosis (water stress, nutrient deficiency, pest/disease)
 - Climate-smart farming recommendations
-- Regional crop knowledge (wheat, rice, cotton, sugarcane, pulses, etc.)
-
-Communication Style:
-- Use simple, practical language farmers can understand
-- Mention specific numbers from data when available
-- Give actionable recommendations
-- Reference local conditions when possible
+- Regional crop knowledge (wheat, rice, cotton, sugarcane, pulses, mustard, etc.)
+
+COMMUNICATION STYLE:
+- Use simple, practical language farmers understand
+- Cite specific values from satellite data when available
+- Distinguish ROOT CAUSE from SYMPTOMS
+- Give actionable, prioritized recommendations
+- Reference local conditions and seasonal context
 - Be concise but thorough
 
-When you lack specific data, acknowledge it and give general guidance."""
+ANALYSIS APPROACH:
+- Always consider multiple hypotheses before concluding
+- Seek contradicting evidence actively
+- Build causal chains: Event A → Effect B → Symptom C
+- Confidence scores reflect evidence strength
+
+When you lack specific data, acknowledge it honestly and provide general guidance based on described symptoms."""
 
 # =============================================================================
-# STAGE 1: CLAIM PROMPT
+# STAGE 3A: CLAIM PROMPT - Initial Hypothesis
 # =============================================================================
 
 CLAIM_PROMPT = """You are analyzing agricultural satellite data to diagnose crop issues.
 
 USER QUERY: {query}
 
-AVAILABLE EVIDENCE (Primary indicators only):
+AVAILABLE EVIDENCE (Priority 1 - Primary indicators only):
 {priority_1_context}
 
 Based ONLY on this primary evidence:
 1. State your initial hypothesis about what's happening
-2. Cite specific values that support your hypothesis  
+2. Cite specific values that support your hypothesis
 3. Rate your confidence (0.0 to 1.0)
+4. List what you're unsure about
 
-Respond in JSON format:
+Respond in JSON format ONLY:
 {{
-    "initial_claim": "Your hypothesis in 1-2 sentences",
-    "hypothesis": "single_word_label",
-    "evidence_cited": ["index1: value", "index2: value"],
-    "confidence": 0.X,
-    "uncertainties": ["what you're unsure about"]
-}}"""
+    "initial_claim": "Your hypothesis in 1-2 sentences describing what's likely happening",
+    "hypothesis": "single_word_label (e.g., chlorophyll_deficiency, water_stress, nutrient_issue)",
+    "evidence_cited": ["NDVI: 0.45", "NDRE: 0.32", "trend: declining"],
+    "confidence": 0.72,
+    "uncertainties": ["cannot determine spatial distribution", "need weather data"]
+}}
+
+Return ONLY the JSON object, no additional text."""
 
 # =============================================================================
-# STAGE 2: VALIDATE PROMPT
+# STAGE 3B: VALIDATE PROMPT - Confirm with Supporting Evidence
 # =============================================================================
 
 VALIDATE_PROMPT = """You previously hypothesized: {previous_hypothesis}
 Initial confidence: {previous_confidence}
 
-ADDITIONAL SUPPORTING EVIDENCE:
+ADDITIONAL SUPPORTING EVIDENCE (Priority 2):
 {priority_2_context}
 
-Does this new evidence:
-1. CONFIRM your hypothesis? (increases confidence)
-2. WEAKEN your hypothesis? (decreases confidence)
-3. Add SPATIAL context? (where is the issue concentrated?)
+Analyze this new evidence and determine:
+1. Does it CONFIRM your hypothesis? (increases confidence)
+2. Does it WEAKEN your hypothesis? (decreases confidence)
+3. Does it add SPATIAL context? (where is the issue concentrated?)
 
-Respond in JSON format:
+Respond in JSON format ONLY:
 {{
     "validation_result": "confirmed|weakened|neutral",
-    "confidence_updated": 0.X,
-    "spatial_notes": "location details if any",
-    "reasoning": "why confidence changed"
-}}"""
+    "confidence_updated": 0.81,
+    "spatial_notes": "Stress concentrated in northeast quadrant, 12 patches affected",
+    "new_evidence_summary": "EVI also low (0.38), clustering shows 18.75% field under stress"
+}}
+
+Return ONLY the JSON object, no additional text."""
 
 # =============================================================================
-# STAGE 3: CONTRADICT PROMPT
+# STAGE 3C: CONTRADICT PROMPT - Seek Alternative Explanations
 # =============================================================================
 
 CONTRADICT_PROMPT = """CURRENT HYPOTHESIS: {hypothesis} (confidence: {confidence})
 
-YOUR TASK: Actively look for evidence that CONTRADICTS this hypothesis.
+YOUR CRITICAL TASK: Actively look for evidence that CONTRADICTS this hypothesis.
+Do NOT confirm - seek alternative explanations!
 
-ALTERNATIVE CAUSAL FACTORS TO CONSIDER:
+ALTERNATIVE CAUSAL FACTORS TO CONSIDER (Priority 3):
 {priority_3_context}
 
 Questions to answer:
-1. Could something ELSE explain the symptoms?
-2. Is there evidence that contradicts the current hypothesis?
-3. What's an alternative explanation?
+1. Could something ELSE explain the observed symptoms?
+2. Is there evidence that CONTRADICTS the current hypothesis?
+3. What's the strongest alternative explanation?
+4. Could the current hypothesis be a SYMPTOM of a deeper ROOT CAUSE?
 
-Respond in JSON format:
+Respond in JSON format ONLY:
 {{
-    "contradiction_found": true|false,
-    "contradicting_evidence": ["evidence that doesn't fit"],
-    "alternative_hypothesis": "alternative explanation",
-    "alternative_confidence": 0.X,
-    "reasoning": "why alternative might be correct"
-}}"""
+    "contradiction_found": true,
+    "contradicting_evidence": ["SMI critically low (0.18)", "5 consecutive heat stress days"],
+    "alternative_hypothesis": "water_stress",
+    "alternative_confidence": 0.76,
+    "reasoning": "Low SMI and heat stress suggest water deficit as ROOT CAUSE. The chlorophyll deficiency may be a SYMPTOM of water stress, not the primary issue."
+}}
+
+Return ONLY the JSON object, no additional text."""
 
 # =============================================================================
-# STAGE 4: CONFIRM PROMPT
+# STAGE 3D: CONFIRM PROMPT - Final Diagnosis
 # =============================================================================
 
 CONFIRM_PROMPT = """COMPETING HYPOTHESES:
 1. {hypothesis_1} (confidence: {conf_1})
 2. {hypothesis_2} (confidence: {conf_2})
 
-FINAL VALIDATION DATA:
+FINAL VALIDATION DATA (Priority 4):
 {priority_4_context}
 
 Determine the FINAL diagnosis by:
-1. Weighing evidence for each hypothesis
-2. Considering farmer's recent actions
-3. Checking consistency with previous analyses
+1. Weighing evidence for EACH hypothesis against this validation data
+2. Considering farmer's recent actions and their impact
+3. Checking consistency with any previous analyses
 4. Identifying the ROOT CAUSE vs symptoms
+5. Building a causal chain explaining how events led to current state
 
-Respond in JSON format:
+Respond in JSON format ONLY:
 {{
-    "final_diagnosis": "clear diagnosis statement",
-    "confidence": 0.X,
-    "causal_chain": "A → B → C → symptom",
-    "root_cause": "the underlying cause",
-    "symptoms": ["observable symptoms"],
-    "recommendation": "what to do next"
-}}"""
+    "final_diagnosis": "water_stress_induced_chlorophyll_decline",
+    "confidence": 0.89,
+    "causal_chain": "Heat stress (5 days >38°C) + No irrigation (8 days) → Soil moisture deficit (SMI 0.18) → Plant water stress → Reduced nutrient uptake → Chlorophyll degradation (NDRE 0.32) → Visible yellowing",
+    "root_cause": "water_stress",
+    "symptoms": ["chlorophyll_decline", "yellowing_leaves", "low_NDRE"],
+    "evidence_summary": {{
+        "supporting": ["SAR VV increasing (drier soil)", "last irrigation 8 days ago"],
+        "contradicting": ["no pest/disease indicators"],
+        "inconclusive": ["nitrogen status unclear without fertilizer history"]
+    }},
+    "recommendation": "Irrigate immediately, prioritizing northeast sector where stress is highest. Consider light foliar feeding once moisture is restored."
+}}
+
+Return ONLY the JSON object, no additional text."""
 
 # =============================================================================
 # RESPONSE GENERATION PROMPT
@@ -141,16 +166,43 @@ EVIDENCE SUMMARY:
 {evidence}
 
 Generate a response that:
-1. Directly answers the farmer's question
-2. Explains the diagnosis in simple terms
-3. Cites key evidence (with numbers)
-4. Provides actionable recommendations
-5. Is concise but complete (3-5 paragraphs max)
-
-Use emojis sparingly for visual clarity (📊 for data, 🔬 for analysis, ✅ for recommendations).
+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
 
 Respond in natural language (not JSON)."""
 
+# =============================================================================
+# FOLLOWUP GENERATION PROMPT
+# =============================================================================
+
+FOLLOWUP_PROMPT = """Based on this conversation:
+
+USER QUERY: {query}
+DIAGNOSIS: {diagnosis}
+INTENT: {intent}
+
+Generate 3 relevant follow-up questions the farmer might want to ask next.
+
+Rules:
+- Make them specific to the diagnosis and context
+- Include at least one spatial question ("Which area...")
+- Include at least one action question ("How do I...")
+- Keep them short and natural-sounding
+
+Respond as a JSON list:
+["Question 1?", "Question 2?", "Question 3?"]"""
+
 # =============================================================================
 # HELPER FUNCTIONS
 # =============================================================================
@@ -162,23 +214,78 @@ def build_context_prompt(context: dict) -> str:
     
     lines = []
     for key, value in context.items():
+        if value is None:
+            continue
         if isinstance(value, dict):
             lines.append(f"**{key}**:")
             for k, v in value.items():
-                lines.append(f"  - {k}: {v}")
+                if v is not None:
+                    if isinstance(v, float):
+                        lines.append(f"  - {k}: {v:.4f}")
+                    else:
+                        lines.append(f"  - {k}: {v}")
         elif isinstance(value, list):
-            lines.append(f"**{key}**: {', '.join(str(v) for v in value)}")
+            if len(value) > 0:
+                lines.append(f"**{key}**: {value}")
         else:
-            lines.append(f"**{key}**: {value}")
+            if isinstance(value, float):
+                lines.append(f"**{key}**: {value:.4f}")
+            else:
+                lines.append(f"**{key}**: {value}")
     
-    return "\n".join(lines)
+    return "\n".join(lines) if lines else "No specific data available."
 
 
 def format_stage_prompt(template: str, **kwargs) -> str:
     """Format a stage prompt with provided values."""
     # Convert context dicts to strings
+    formatted_kwargs = {}
     for key, value in kwargs.items():
         if isinstance(value, dict):
-            kwargs[key] = build_context_prompt(value)
+            formatted_kwargs[key] = build_context_prompt(value)
+        else:
+            formatted_kwargs[key] = value
+    
+    return template.format(**formatted_kwargs)
+
+
+def generate_followup_questions(intent: str, diagnosis: str) -> list:
+    """Generate suggested followup questions based on intent and diagnosis."""
+    followup_templates = {
+        "vegetation_health": [
+            "Which part of my field is most affected?",
+            "How much water/fertilizer should I apply?",
+            "Will this damage spread if I don't act now?"
+        ],
+        "water_stress": [
+            "How much should I irrigate?",
+            "Is rain expected this week?",
+            "Which zone needs water most urgently?"
+        ],
+        "nutrient_status": [
+            "Which fertilizer should I use?",
+            "How much fertilizer per acre?",
+            "When is the best time to apply?"
+        ],
+        "pest_disease": [
+            "What pesticide should I use?",
+            "How fast is this spreading?",
+            "Should I quarantine the affected area?"
+        ],
+        "forecast_query": [
+            "What should I prepare for?",
+            "How will weather affect my crop next week?",
+            "When is the best time to harvest?"
+        ],
+        "action_recommendation": [
+            "How soon should I act?",
+            "What's the most cost-effective solution?",
+            "Can I wait for rain instead of irrigating?"
+        ]
+    }
     
-    return template.format(**kwargs)
+    return followup_templates.get(intent, [
+        "What should I do next?",
+        "Is my crop at risk?",
+        "How can I prevent this in the future?"
+    ])

reasoning_engine.py

@@ -1,25 +1,30 @@
 """
 Multi-Stage Reasoning Engine for Agricultural Chatbot
 ======================================================
-Implements: Claim → Validate → Contradict → Confirm pipeline
+Implements the full spec: Claim → Validate → Contradict → Confirm pipeline
+with priority-based context selection and evidence tracking.
 """
 
 import json
 import logging
-from typing import Dict, List, Any, Optional, Tuple
-from dataclasses import dataclass
+from typing import Dict, List, Any, Optional, Tuple, Callable
+from dataclasses import dataclass, field
 
 from intent_classifier import IntentClassifier
 from priority_mapper import PriorityContextMapper
 from prompts import (
     SYSTEM_PROMPT, CLAIM_PROMPT, VALIDATE_PROMPT, 
     CONTRADICT_PROMPT, CONFIRM_PROMPT, RESPONSE_PROMPT,
-    format_stage_prompt, build_context_prompt
+    format_stage_prompt, build_context_prompt, generate_followup_questions
 )
 
 logger = logging.getLogger("ReasoningEngine")
 
 
+# =============================================================================
+# DATA CLASSES
+# =============================================================================
+
 @dataclass
 class StageResult:
     """Result from a single reasoning stage."""
@@ -27,6 +32,7 @@ class StageResult:
     output: Dict[str, Any]
     context_used: List[str]
     confidence: float
+    raw_response: str = ""
 
 
 @dataclass
@@ -39,17 +45,28 @@ class ReasoningResult:
     final_diagnosis: str
     final_confidence: float
     causal_chain: str
+    root_cause: str
+    symptoms: List[str]
     recommendation: str
     evidence_summary: Dict[str, List[str]]
 
 
+# =============================================================================
+# REASONING ENGINE
+# =============================================================================
+
 class ReasoningEngine:
     """
     Multi-stage reasoning engine for agricultural chatbot.
-    Does NOT ingest all context - uses priority-based selection.
+    
+    Following the spec:
+    - Does NOT ingest all context at once
+    - Uses priority-based context selection per intent
+    - Actively seeks contradictions in Stage C
+    - Tracks evidence chain for transparency
     """
     
-    def __init__(self, llm_caller):
+    def __init__(self, llm_caller: Callable[[str], str]):
         """
         Args:
             llm_caller: Function that takes (prompt: str) -> str
@@ -64,7 +81,7 @@ class ReasoningEngine:
         context: Optional[Dict[str, Any]] = None
     ) -> Tuple[str, Dict[str, Any]]:
         """
-        Process a user query through the full reasoning pipeline.
+        Process user query through full reasoning pipeline.
         
         Returns:
             (response_text, reasoning_trace)
@@ -73,9 +90,9 @@ class ReasoningEngine:
         
         # Stage 1: Classify intent
         intent = self.intent_classifier.classify(query)
-        logger.info(f"Detected intent: {intent['primary_intent']} ({intent['confidence']})")
+        logger.info(f"Intent: {intent['primary_intent']} ({intent['confidence']})")
         
-        # Stage 2: Get prioritized context
+        # Stage 2: Get prioritized context (NOT all context at once!)
         staged_context = self.priority_mapper.build_staged_context(
             intent=intent["primary_intent"],
             full_context=context or {}
@@ -87,8 +104,14 @@ class ReasoningEngine:
         # Stage 4: Generate response
         response = self._generate_response(query, reasoning_result)
         
-        # Build reasoning trace
-        trace = self._build_trace(intent, reasoning_result, staged_context)
+        # Stage 5: Generate followups
+        followups = generate_followup_questions(
+            intent["primary_intent"],
+            reasoning_result.final_diagnosis
+        )
+        
+        # Build complete trace
+        trace = self._build_trace(intent, reasoning_result, staged_context, followups)
         
         return response, trace
     
@@ -98,28 +121,34 @@ class ReasoningEngine:
         intent: Dict, 
         staged_context: Dict
     ) -> ReasoningResult:
-        """Execute 4-stage reasoning pipeline."""
+        """Execute 4-stage reasoning pipeline as per spec."""
         
-        # Stage A: Initial Claim
+        # Stage A: Initial Claim (Priority 1 context only)
+        logger.info("Stage A: Making initial claim...")
         claim = self._stage_claim(query, staged_context["claim_context"])
         
-        # Stage B: Validate
+        # Stage B: Validate (Add Priority 2 context)
+        logger.info(f"Stage B: Validating hypothesis '{claim.output.get('hypothesis')}'...")
         validation = self._stage_validate(
-            claim.output.get("hypothesis", "unknown"),
-            claim.confidence,
-            staged_context["validate_context"]
+            hypothesis=claim.output.get("hypothesis", "unknown"),
+            confidence=claim.confidence,
+            context=staged_context["validate_context"]
         )
         
-        # Stage C: Contradict
+        # Stage C: Contradict (Priority 3 - actively seek alternatives)
+        current_hypothesis = validation.output.get("hypothesis", 
+                                                   claim.output.get("hypothesis", "unknown"))
+        logger.info(f"Stage C: Seeking contradictions to '{current_hypothesis}'...")
         contradiction = self._stage_contradict(
-            validation.output.get("hypothesis", claim.output.get("hypothesis", "unknown")),
-            validation.confidence,
-            staged_context["contradict_context"]
+            hypothesis=current_hypothesis,
+            confidence=validation.confidence,
+            context=staged_context["contradict_context"]
         )
         
-        # Stage D: Confirm
+        # Stage D: Confirm (Priority 4 - final decision)
+        logger.info("Stage D: Final confirmation...")
         confirmation = self._stage_confirm(
-            hypothesis_1=claim.output.get("hypothesis", "unknown"),
+            hypothesis_1=current_hypothesis,
             conf_1=validation.confidence,
             hypothesis_2=contradiction.output.get("alternative_hypothesis", "none"),
             conf_2=contradiction.output.get("alternative_confidence", 0),
@@ -134,17 +163,22 @@ class ReasoningEngine:
             final_diagnosis=confirmation.output.get("final_diagnosis", "Undetermined"),
             final_confidence=confirmation.confidence,
             causal_chain=confirmation.output.get("causal_chain", ""),
+            root_cause=confirmation.output.get("root_cause", "unknown"),
+            symptoms=confirmation.output.get("symptoms", []),
             recommendation=confirmation.output.get("recommendation", ""),
             evidence_summary={
                 "primary": claim.context_used,
                 "supporting": validation.context_used,
                 "alternative": contradiction.context_used,
-                "validation": confirmation.context_used
+                "validation": confirmation.context_used,
+                "supporting_evidence": confirmation.output.get("evidence_summary", {}).get("supporting", []),
+                "contradicting_evidence": confirmation.output.get("evidence_summary", {}).get("contradicting", []),
+                "inconclusive_evidence": confirmation.output.get("evidence_summary", {}).get("inconclusive", [])
             }
         )
     
     def _stage_claim(self, query: str, context: Dict) -> StageResult:
-        """Stage 3A: Make initial claim using Priority 1 context."""
+        """Stage 3A: Make initial claim using Priority 1 context only."""
         prompt = format_stage_prompt(
             CLAIM_PROMPT,
             query=query,
@@ -154,20 +188,20 @@ class ReasoningEngine:
         full_prompt = f"{SYSTEM_PROMPT}\n\n{prompt}"
         response = self.llm(full_prompt)
         
-        try:
-            output = self._parse_json(response)
-        except:
-            output = {
-                "initial_claim": response,
-                "hypothesis": "general_issue",
-                "confidence": 0.5
-            }
+        output = self._parse_json_safe(response, {
+            "initial_claim": response[:200] if response else "No analysis available",
+            "hypothesis": "general_issue",
+            "evidence_cited": list(context.keys()),
+            "confidence": 0.5,
+            "uncertainties": ["Limited data available"]
+        })
         
         return StageResult(
             stage="claim",
             output=output,
             context_used=list(context.keys()),
-            confidence=output.get("confidence", 0.5)
+            confidence=output.get("confidence", 0.5),
+            raw_response=response
         )
     
     def _stage_validate(
@@ -187,13 +221,12 @@ class ReasoningEngine:
         full_prompt = f"{SYSTEM_PROMPT}\n\n{prompt}"
         response = self.llm(full_prompt)
         
-        try:
-            output = self._parse_json(response)
-        except:
-            output = {
-                "validation_result": "neutral",
-                "confidence_updated": confidence
-            }
+        output = self._parse_json_safe(response, {
+            "validation_result": "neutral",
+            "confidence_updated": confidence,
+            "spatial_notes": "Unable to determine spatial distribution",
+            "new_evidence_summary": ""
+        })
         
         # Carry forward hypothesis
         output["hypothesis"] = hypothesis
@@ -202,7 +235,8 @@ class ReasoningEngine:
             stage="validate",
             output=output,
             context_used=list(context.keys()),
-            confidence=output.get("confidence_updated", confidence)
+            confidence=output.get("confidence_updated", confidence),
+            raw_response=response
         )
     
     def _stage_contradict(
@@ -211,7 +245,7 @@ class ReasoningEngine:
         confidence: float, 
         context: Dict
     ) -> StageResult:
-        """Stage 3C: Seek contradictions using Priority 3 context."""
+        """Stage 3C: Actively seek contradictions using Priority 3 context."""
         prompt = format_stage_prompt(
             CONTRADICT_PROMPT,
             hypothesis=hypothesis,
@@ -222,20 +256,20 @@ class ReasoningEngine:
         full_prompt = f"{SYSTEM_PROMPT}\n\n{prompt}"
         response = self.llm(full_prompt)
         
-        try:
-            output = self._parse_json(response)
-        except:
-            output = {
-                "contradiction_found": False,
-                "alternative_hypothesis": "none",
-                "alternative_confidence": 0
-            }
+        output = self._parse_json_safe(response, {
+            "contradiction_found": False,
+            "contradicting_evidence": [],
+            "alternative_hypothesis": "none",
+            "alternative_confidence": 0.0,
+            "reasoning": "No strong contradicting evidence found"
+        })
         
         return StageResult(
             stage="contradict",
             output=output,
             context_used=list(context.keys()),
-            confidence=output.get("alternative_confidence", 0)
+            confidence=output.get("alternative_confidence", 0.0),
+            raw_response=response
         )
     
     def _stage_confirm(
@@ -251,7 +285,7 @@ class ReasoningEngine:
             CONFIRM_PROMPT,
             hypothesis_1=hypothesis_1,
             conf_1=conf_1,
-            hypothesis_2=hypothesis_2,
+            hypothesis_2=hypothesis_2 if hypothesis_2 != "none" else "no_alternative",
             conf_2=conf_2,
             priority_4_context=context
         )
@@ -259,34 +293,47 @@ class ReasoningEngine:
         full_prompt = f"{SYSTEM_PROMPT}\n\n{prompt}"
         response = self.llm(full_prompt)
         
-        try:
-            output = self._parse_json(response)
-        except:
-            # Generate simple output if parsing fails
-            output = {
-                "final_diagnosis": f"Likely {hypothesis_1}",
-                "confidence": conf_1,
-                "recommendation": "Further investigation recommended"
-            }
+        # Pick the more confident hypothesis as default
+        default_diagnosis = hypothesis_1 if conf_1 >= conf_2 else hypothesis_2
+        default_conf = max(conf_1, conf_2)
+        
+        output = self._parse_json_safe(response, {
+            "final_diagnosis": default_diagnosis,
+            "confidence": default_conf,
+            "causal_chain": f"{default_diagnosis} leads to observed symptoms",
+            "root_cause": default_diagnosis,
+            "symptoms": [],
+            "evidence_summary": {
+                "supporting": list(context.keys()),
+                "contradicting": [],
+                "inconclusive": []
+            },
+            "recommendation": "Further investigation recommended based on available data"
+        })
         
         return StageResult(
             stage="confirm",
             output=output,
             context_used=list(context.keys()),
-            confidence=output.get("confidence", conf_1)
+            confidence=output.get("confidence", default_conf),
+            raw_response=response
         )
     
     def _generate_response(self, query: str, result: ReasoningResult) -> str:
         """Generate final user-facing response."""
+        diagnosis_data = {
+            "diagnosis": result.final_diagnosis,
+            "confidence": result.final_confidence,
+            "causal_chain": result.causal_chain,
+            "root_cause": result.root_cause,
+            "symptoms": result.symptoms,
+            "recommendation": result.recommendation
+        }
+        
         prompt = format_stage_prompt(
             RESPONSE_PROMPT,
             query=query,
-            diagnosis=json.dumps({
-                "diagnosis": result.final_diagnosis,
-                "confidence": result.final_confidence,
-                "causal_chain": result.causal_chain,
-                "recommendation": result.recommendation
-            }, indent=2),
+            diagnosis=json.dumps(diagnosis_data, indent=2),
             evidence=json.dumps(result.evidence_summary, indent=2)
         )
         
@@ -299,9 +346,10 @@ class ReasoningEngine:
         self, 
         intent: Dict, 
         result: ReasoningResult,
-        staged_context: Dict
+        staged_context: Dict,
+        followups: List[str]
     ) -> Dict[str, Any]:
-        """Build reasoning trace for debugging/transparency."""
+        """Build reasoning trace for transparency as per spec."""
         return {
             "intent_detected": intent["primary_intent"],
             "intent_confidence": intent["confidence"],
@@ -309,58 +357,84 @@ class ReasoningEngine:
             "stages": {
                 "claim": {
                     "hypothesis": result.claim.output.get("hypothesis"),
+                    "initial_claim": result.claim.output.get("initial_claim"),
                     "confidence": result.claim.confidence,
-                    "context_used": result.claim.context_used
+                    "context_used": result.claim.context_used,
+                    "evidence_cited": result.claim.output.get("evidence_cited", [])
                 },
                 "validation": {
                     "result": result.validation.output.get("validation_result"),
                     "confidence": result.validation.confidence,
+                    "spatial_notes": result.validation.output.get("spatial_notes"),
                     "context_used": result.validation.context_used
                 },
                 "contradiction": {
                     "found": result.contradiction.output.get("contradiction_found"),
                     "alternative": result.contradiction.output.get("alternative_hypothesis"),
-                    "confidence": result.contradiction.confidence,
+                    "alternative_confidence": result.contradiction.output.get("alternative_confidence"),
+                    "reasoning": result.contradiction.output.get("reasoning"),
                     "context_used": result.contradiction.context_used
                 },
                 "confirmation": {
                     "final": result.final_diagnosis,
                     "confidence": result.final_confidence,
+                    "root_cause": result.root_cause,
+                    "causal_chain": result.causal_chain,
                     "context_used": result.confirmation.context_used
                 }
             },
             "causal_chain": result.causal_chain,
-            "evidence_summary": result.evidence_summary
+            "root_cause": result.root_cause,
+            "symptoms": result.symptoms,
+            "evidence_summary": result.evidence_summary,
+            "context_priority_used": {
+                "priority_1": list(staged_context.get("claim_context", {}).keys()),
+                "priority_2": list(staged_context.get("validate_context", {}).keys()),
+                "priority_3": list(staged_context.get("contradict_context", {}).keys()),
+                "priority_4": list(staged_context.get("confirm_context", {}).keys())
+            },
+            "suggested_followups": followups
         }
     
-    def _parse_json(self, text: str) -> Dict:
-        """Extract and parse JSON from LLM response."""
-        # Try to find JSON in response
+    def _parse_json_safe(self, text: str, default: Dict) -> Dict:
+        """Safely extract and parse JSON from LLM response."""
+        if not text:
+            return default
+        
         text = text.strip()
         
-        # Look for JSON block
+        # Look for JSON code block
         if "```json" in text:
             start = text.find("```json") + 7
             end = text.find("```", start)
-            text = text[start:end].strip()
+            if end > start:
+                text = text[start:end].strip()
         elif "```" in text:
             start = text.find("```") + 3
             end = text.find("```", start)
-            text = text[start:end].strip()
+            if end > start:
+                text = text[start:end].strip()
         
         # Find JSON object
         start = text.find("{")
         end = text.rfind("}") + 1
+        
         if start >= 0 and end > start:
-            text = text[start:end]
+            try:
+                return json.loads(text[start:end])
+            except json.JSONDecodeError as e:
+                logger.warning(f"JSON parse error: {e}")
         
-        return json.loads(text)
+        return default
 
 
-# Simple interface for single-stage reasoning (fallback)
-def simple_reason(query: str, context: Dict, llm_caller) -> str:
+# =============================================================================
+# SIMPLE REASONING (Fallback)
+# =============================================================================
+
+def simple_reason(query: str, context: Dict, llm_caller: Callable) -> str:
     """Simplified single-stage reasoning for when full pipeline isn't needed."""
-    context_str = build_context_prompt(context) if context else "No context available."
+    context_str = build_context_prompt(context) if context else "No specific field data available."
     
     prompt = f"""{SYSTEM_PROMPT}
 
@@ -369,6 +443,13 @@ User Query: {query}
 Available Context:
 {context_str}
 
-Provide a helpful, actionable response."""
+Provide a helpful, actionable response. If specific data is available, cite it.
+If not, provide general guidance based on the query.
+
+Use this format:
+1. Direct answer to the question
+2. Key observations from data (if available)
+3. Practical recommendations
+4. What to monitor or check next"""
     
     return llm_caller(prompt)