Add satellite band data injection from HF Space APIs (SAR, Sentinel-2)

app.py

@@ -23,6 +23,7 @@ from pydantic import BaseModel
 from supabase_client import SupabaseClient
 from reasoning_engine import ReasoningEngine, simple_reason
 from intent_classifier import IntentClassifier
+from context_aggregator import ContextAggregator, fetch_field_context
 
 # ============================================================================
 # LOGGING
@@ -287,6 +288,25 @@ async def chat(request: ChatRequest):
         intent = intent_classifier.classify(request.message)
         logger.info(f"Intent: {intent['primary_intent']} ({intent['confidence']})")
         
+        # Fetch satellite data for technical queries (vegetation, water, nutrient intents)
+        satellite_intents = ["vegetation_health", "water_stress", "nutrient_status", "pest_disease", "forecast_query"]
+        if (intent["primary_intent"] in satellite_intents and 
+            context.get("coordinates") and 
+            intent["confidence"] > 0.5):
+            
+            logger.info("Fetching satellite data from HF Space APIs...")
+            try:
+                satellite_context = fetch_field_context(
+                    coordinates=context.get("coordinates"),
+                    crop_type=context.get("crop_type", "Wheat"),
+                    area_acres=context.get("area_acres", 1.0),
+                    fetch_satellite=True
+                )
+                context.update(satellite_context)
+                logger.info(f"Satellite data loaded: {list(satellite_context.keys())}")
+            except Exception as e:
+                logger.warning(f"Could not fetch satellite data: {e}")
+        
         # Determine if we need full reasoning or simple response
         use_full_reasoning = (
             intent["confidence"] > 0.6 and 
@@ -413,7 +433,60 @@ async def analyze_intent(request: Dict[str, str]):
     }
 
 
+# Satellite context endpoint (for debugging and direct access)
+@app.post("/satellite-context")
+async def get_satellite_context(request: Dict[str, Any]):
+    """
+    Fetch satellite band data from HF Space APIs.
+    
+    Request body:
+    {
+        "user_id": "firebase_or_anon_id",
+        "coordinates": {"center_lat": 30.9, "center_lon": 75.8, "bbox": [...]},
+        "crop_type": "Wheat",
+        "area_acres": 1.0
+    }
+    """
+    logger.info("Fetching satellite context...")
+    
+    user_id = request.get("user_id")
+    coordinates = request.get("coordinates")
+    crop_type = request.get("crop_type", "Wheat")
+    area_acres = request.get("area_acres", 1.0)
+    
+    # If user_id provided, fetch from Supabase
+    if user_id and not coordinates:
+        field_context = supabase.get_field_context(user_id)
+        if field_context:
+            coordinates = field_context.get("coordinates")
+            crop_type = field_context.get("crop_type", crop_type)
+            area_acres = field_context.get("area_acres", area_acres)
+    
+    if not coordinates:
+        return {"error": "No coordinates available", "data": None}
+    
+    try:
+        aggregator = ContextAggregator(timeout=60)
+        raw_context = aggregator.fetch_full_context(
+            coordinates=coordinates,
+            crop_type=crop_type,
+            area_acres=area_acres
+        )
+        formatted_context = aggregator.format_for_llm(raw_context)
+        
+        return {
+            "success": True,
+            "raw_context": raw_context,
+            "formatted_context": formatted_context,
+            "timestamp": datetime.now().isoformat()
+        }
+    except Exception as e:
+        logger.error(f"Satellite context error: {e}")
+        return {"success": False, "error": str(e)}
+
+
 if __name__ == "__main__":
     import uvicorn
     logger.info("Starting AGROW Chatbot Service v2.0")
     uvicorn.run(app, host="0.0.0.0", port=7860)
+

context_aggregator.py

@@ -0,0 +1,362 @@
+"""
+Context Aggregator for Agricultural Chatbot
+=============================================
+Fetches satellite data from HF Space APIs and formats for LLM context.
+"""
+
+import os
+import logging
+import requests
+from typing import Dict, List, Any, Optional
+from datetime import datetime
+
+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"
+
+
+class ContextAggregator:
+    """
+    Aggregates satellite data from multiple HF Space APIs.
+    Returns structured JSON for LLM context injection.
+    """
+    
+    def __init__(self, timeout: int = 30):
+        self.timeout = timeout
+    
+    def fetch_full_context(
+        self,
+        coordinates: Dict[str, Any],
+        crop_type: str = "Wheat",
+        area_acres: float = 1.0,
+        farmer_context: Optional[Dict] = None
+    ) -> Dict[str, Any]:
+        """
+        Fetch complete satellite context for a field.
+        
+        Args:
+            coordinates: {"center_lat": float, "center_lon": float, "bbox": [lon_min, lat_min, lon_max, lat_max]}
+            crop_type: Type of crop
+            area_acres: Field size in acres
+            farmer_context: Additional farmer profile data
+            
+        Returns:
+            {
+                "vegetation_indices": {...},
+                "sar_data": {...},
+                "soil_indicators": {...},
+                "weather_data": {...},
+                "anomalies": {...},
+                "temporal_trends": {...}
+            }
+        """
+        context = {
+            "fetch_timestamp": datetime.now().isoformat(),
+            "field_info": {
+                "crop_type": crop_type,
+                "area_acres": area_acres,
+                "coordinates": coordinates
+            }
+        }
+        
+        if not coordinates:
+            return context
+        
+        center_lat = coordinates.get("center_lat")
+        center_lon = coordinates.get("center_lon")
+        bbox = coordinates.get("bbox")
+        
+        if not center_lat or not center_lon:
+            return context
+        
+        # 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["patches"] = sar_data.get("patches", [])
+            context["stressed_patches"] = sar_data.get("stressed_patches", [])
+            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)
+        if s2_data:
+            context["vegetation_indices"] = s2_data.get("vegetation_indices", {})
+            context["soil_indicators"] = s2_data.get("soil_indicators", {})
+            context["llm_analysis"] = s2_data.get("llm_analysis", {})
+            context["sentinel2_bands"] = s2_data.get("band_values", {})
+        
+        return context
+    
+    def _fetch_sar_data(
+        self, 
+        bbox: List[float], 
+        crop_type: str,
+        farmer_context: Optional[Dict]
+    ) -> Optional[Dict]:
+        """Fetch SAR analysis from HF Space."""
+        if not bbox or len(bbox) < 4:
+            return None
+        
+        try:
+            response = requests.post(
+                f"{SAR_API_URL}/analyze",
+                json={
+                    "coordinates": bbox,
+                    "date": datetime.now().strftime("%Y-%m-%d"),
+                    "crop_type": crop_type,
+                    "farmer_context": farmer_context
+                },
+                timeout=self.timeout
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                logger.info(f"SAR data fetched: {list(data.keys())}")
+                return data
+            else:
+                logger.warning(f"SAR API error: {response.status_code}")
+                return None
+                
+        except Exception as e:
+            logger.error(f"SAR fetch error: {e}")
+            return None
+    
+    def _fetch_sentinel2_data(
+        self,
+        center_lat: float,
+        center_lon: float,
+        crop_type: str,
+        area_acres: 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={
+                    "center_lat": center_lat,
+                    "center_lon": center_lon,
+                    "crop_type": crop_type,
+                    "analysis_date": datetime.now().strftime("%Y-%m-%d"),
+                    "field_size_hectares": field_hectares,
+                    "farmer_context": farmer_context or {}
+                },
+                timeout=self.timeout
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                logger.info(f"Sentinel-2 data fetched: {list(data.keys())}")
+                return data
+            else:
+                logger.warning(f"Sentinel-2 API error: {response.status_code}")
+                return None
+                
+        except Exception as e:
+            logger.error(f"Sentinel-2 fetch error: {e}")
+            return None
+    
+    def fetch_specific_metrics(
+        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
+                )
+                
+                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 results
+    
+    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", {}),
+        }
+        
+        # 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))
+                }
+            }
+        
+        # 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")
+            }
+        
+        # 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)
+            }
+        
+        # Weather
+        weather = context.get("weather_data", [])
+        if weather:
+            latest = weather[0] if weather else {}
+            formatted["weather"] = {
+                "current": latest,
+                "recent_days": len(weather)
+            }
+        
+        # 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")
+            }
+        
+        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"
+    
+    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"
+
+
+# Quick context fetch function
+def fetch_field_context(
+    coordinates: Dict[str, Any],
+    crop_type: str = "Wheat",
+    area_acres: float = 1.0,
+    fetch_satellite: bool = True
+) -> Dict[str, Any]:
+    """
+    Quick function to fetch and format field context.
+    
+    Args:
+        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)
+    """
+    aggregator = ContextAggregator()
+    
+    if fetch_satellite:
+        raw_context = aggregator.fetch_full_context(
+            coordinates=coordinates,
+            crop_type=crop_type,
+            area_acres=area_acres
+        )
+        return aggregator.format_for_llm(raw_context)
+    else:
+        return {
+            "field_info": {
+                "crop_type": crop_type,
+                "area_acres": area_acres,
+                "coordinates": coordinates
+            }
+        }