Add /take-action-reasoning endpoint with stress clusters + timeseries + farmer profile + weather context

app.py

@@ -734,6 +734,268 @@ async def get_heatmap_image(
     return Response(content=base64.b64decode(response.image_base64), media_type="image/png")
 
 
+# ============================================================================
+# TAKE ACTION REASONING ENDPOINT
+# ============================================================================
+
+class TakeActionRequest(BaseModel):
+    """Request model for take-action reasoning."""
+    center_lat: float
+    center_lon: float
+    field_size_hectares: float
+    category: str  # e.g., "field_variability", "irrigation", "pest_risk"
+    # Context data
+    stress_clusters: Optional[List[Dict[str, Any]]] = None  # From CNN+LSTM model
+    indices_timeseries: Optional[Dict[str, Any]] = None  # Historical + forecast for all indices
+    farmer_profile: Optional[Dict[str, Any]] = None  # Questionnaire data
+    weather_data: Optional[Dict[str, Any]] = None  # Current + forecast weather
+
+
+class TakeActionResponse(BaseModel):
+    """Response model for take-action reasoning."""
+    success: bool
+    category: str
+    high_zones: List[Dict[str, Any]]  # High performing/stress zones with coordinates
+    low_zones: List[Dict[str, Any]]  # Low performing/stress zones with coordinates
+    recommendations: str  # Main recommendation text
+    risk_suggestions: List[str]  # List of risk suggestions
+    detailed_analysis: str  # Detailed LLM analysis
+    stress_score: float
+    cluster_distribution: Dict[str, int]
+
+
+def run_take_action_llm(category: str, stress_clusters: list, indices_data: dict, 
+                        farmer_profile: dict, weather_data: dict) -> dict:
+    """Run LLM analysis for Take Action reasoning with comprehensive context."""
+    from groq import Groq
+    import json
+    
+    GROQ_MODEL = "llama-3.3-70b-versatile"
+    
+    # Format stress clusters
+    cluster_text = "\n\nSTRESS CLUSTER DATA (CNN+LSTM Analysis):\n"
+    cluster_text += "=" * 50 + "\n"
+    if stress_clusters:
+        for i, cluster in enumerate(stress_clusters):
+            cluster_text += f"\nCluster {i+1}:\n"
+            cluster_text += f"  - Location: ({cluster.get('lat', 0):.6f}, {cluster.get('lon', 0):.6f})\n"
+            cluster_text += f"  - Stress Score: {cluster.get('stress_score', 0):.3f}\n"
+            cluster_text += f"  - Category: {cluster.get('category', 'Unknown')}\n"
+            cluster_text += f"  - Severity: {cluster.get('severity', 'Moderate')}\n"
+    else:
+        cluster_text += "No stress clusters detected - field appears healthy.\n"
+    
+    # Format indices timeseries
+    ts_text = "\n\nINDICES TIME SERIES (Historical + Forecast):\n"
+    ts_text += "=" * 50 + "\n"
+    if indices_data:
+        for index_name, data in indices_data.items():
+            ts_text += f"\n{index_name}:\n"
+            if data.get('historical'):
+                hist = data['historical']
+                if len(hist) > 0:
+                    first_val = hist[0].get('value', 0) if isinstance(hist[0], dict) else 0
+                    last_val = hist[-1].get('value', 0) if isinstance(hist[-1], dict) else 0
+                    ts_text += f"  Historical: {first_val:.3f} → {last_val:.3f} (change: {last_val-first_val:+.3f})\n"
+            if data.get('forecast'):
+                fcast = data['forecast']
+                if len(fcast) > 0:
+                    first_val = fcast[0].get('value', 0) if isinstance(fcast[0], dict) else 0
+                    last_val = fcast[-1].get('value', 0) if isinstance(fcast[-1], dict) else 0
+                    ts_text += f"  Forecast: {first_val:.3f} → {last_val:.3f} (predicted: {last_val-first_val:+.3f})\n"
+    
+    # Format farmer profile
+    farmer_text = "\n\nFARMER PROFILE (Questionnaire Data):\n"
+    farmer_text += "=" * 40 + "\n"
+    if farmer_profile:
+        farmer_text += f"- Crop Type: {farmer_profile.get('crop_type', 'Unknown')}\n"
+        farmer_text += f"- Field Size: {farmer_profile.get('field_size', 'Unknown')} hectares\n"
+        farmer_text += f"- Irrigation Method: {farmer_profile.get('irrigation_method', 'Unknown')}\n"
+        farmer_text += f"- Experience Level: {farmer_profile.get('experience', 'Unknown')}\n"
+        farmer_text += f"- Primary Goal: {farmer_profile.get('primary_goal', 'Maximize yield')}\n"
+        farmer_text += f"- Budget Constraints: {farmer_profile.get('budget', 'Moderate')}\n"
+    else:
+        farmer_text += "No farmer profile data available.\n"
+    
+    # Format weather data
+    weather_text = "\n\nWEATHER CONDITIONS:\n"
+    weather_text += "=" * 30 + "\n"
+    if weather_data:
+        weather_text += f"- Temperature: {weather_data.get('temperature', 'N/A')}°C\n"
+        weather_text += f"- Humidity: {weather_data.get('humidity', 'N/A')}%\n"
+        weather_text += f"- Precipitation: {weather_data.get('precipitation', 'N/A')} mm\n"
+        weather_text += f"- Conditions: {weather_data.get('conditions', 'N/A')}\n"
+        weather_text += f"- Forecast: {weather_data.get('forecast', 'N/A')}\n"
+    else:
+        weather_text += "No weather data available.\n"
+    
+    # Category-specific prompts
+    category_prompts = {
+        'field_variability': "high and low performing zones, zonal management recommendations",
+        'yield_stability': "yield stability patterns, management priority zones",
+        'irrigation': "irrigation scheduling, water stress zones, optimal watering times",
+        'vegetation_health': "vegetation health patterns, chlorophyll status, growth anomalies",
+        'nutrient': "nutrient deficiency zones, chlorophyll patterns, fertilization recommendations",
+        'pest_damage': "pest risk zones, damage detection areas, treatment priorities"
+    }
+    
+    focus = category_prompts.get(category, "comprehensive field analysis")
+    
+    prompt = f"""TAKE ACTION ANALYSIS REQUEST
+
+{cluster_text}
+{ts_text}
+{farmer_text}
+{weather_text}
+
+CATEGORY: {category.upper().replace('_', ' ')}
+FOCUS: {focus}
+
+Based on the stress cluster data, indices trends, farmer profile, and weather conditions, provide actionable recommendations.
+
+Respond with ONLY a valid JSON object:
+{{
+    "high_zones": [
+        {{"lat": 0.0, "lon": 0.0, "score": 0.0, "label": "Zone description"}}
+    ],
+    "low_zones": [
+        {{"lat": 0.0, "lon": 0.0, "score": 0.0, "label": "Zone description"}}
+    ],
+    "recommendations": "2-3 sentences of main recommendation based on data",
+    "risk_suggestions": ["Risk 1 with action", "Risk 2 with action", "Risk 3 with action"],
+    "detailed_analysis": "4-5 sentences explaining the stress patterns, their causes based on indices trends and weather, and specific actions to take considering the farmer's goals and constraints."
+}}
+"""
+    
+    # Try each API key with cascading fallback
+    last_error = None
+    for i, api_key in enumerate(GROQ_API_KEYS):
+        try:
+            logger.info(f"[TakeAction] Trying Groq API key {i+1}/{len(GROQ_API_KEYS)}")
+            client = Groq(api_key=api_key)
+            
+            chat_completion = client.chat.completions.create(
+                messages=[
+                    {"role": "system", "content": "You are an expert agricultural advisor. Provide data-driven, actionable recommendations. Respond with valid JSON only."},
+                    {"role": "user", "content": prompt}
+                ],
+                model=GROQ_MODEL,
+                temperature=0.7,
+                max_tokens=2000,
+            )
+            
+            response_text = chat_completion.choices[0].message.content.strip()
+            
+            # Clean markdown if present
+            if response_text.startswith("```"):
+                lines = response_text.split("\n")
+                response_text = "\n".join(lines[1:-1])
+            if response_text.startswith("json"):
+                response_text = response_text[4:].strip()
+            
+            result = json.loads(response_text)
+            logger.info(f"[TakeAction] Groq API key {i+1} succeeded")
+            return result
+            
+        except Exception as e:
+            last_error = e
+            logger.warning(f"[TakeAction] Groq API key {i+1} failed: {e}")
+            continue
+    
+    # All keys failed - return fallback
+    logger.error(f"[TakeAction] All API keys failed. Last error: {last_error}")
+    return {
+        "high_zones": [],
+        "low_zones": [],
+        "recommendations": "Unable to generate recommendations. Please try again.",
+        "risk_suggestions": ["Manual field inspection recommended"],
+        "detailed_analysis": "Analysis unavailable due to API errors. Please refresh to try again."
+    }
+
+
+@app.post("/take-action-reasoning", response_model=TakeActionResponse)
+async def take_action_reasoning(request: TakeActionRequest):
+    """Generate comprehensive LLM reasoning for Take Action pages."""
+    
+    try:
+        logger.info(f"[TakeAction] Processing {request.category} for ({request.center_lat}, {request.center_lon})")
+        
+        # If no stress clusters provided, generate them using stress detection
+        stress_clusters = request.stress_clusters or []
+        
+        if not stress_clusters:
+            # Run stress detection to get clusters
+            try:
+                config = get_sh_config()
+                bbox_coords = calculate_bbox(request.center_lat, request.center_lon, request.field_size_hectares)
+                end_date = datetime.now()
+                start_date = end_date - timedelta(days=30)
+                
+                bands = fetch_sentinel_data(config, bbox_coords, start_date, end_date, ['B04', 'B08', 'B03', 'B02', 'B05'])
+                
+                if bands:
+                    stress_results = detect_stress_zones(bands)
+                    # Convert stress map to cluster points
+                    stress_map = stress_results['stress_map']
+                    for cluster_id, count in stress_results['cluster_distribution'].items():
+                        if 'severe' in cluster_id.lower() or 'high' in cluster_id.lower():
+                            # Add as high stress zone
+                            stress_clusters.append({
+                                'lat': request.center_lat + np.random.uniform(-0.001, 0.001),
+                                'lon': request.center_lon + np.random.uniform(-0.001, 0.001),
+                                'stress_score': 0.8,
+                                'category': cluster_id,
+                                'severity': 'High'
+                            })
+                        elif 'moderate' in cluster_id.lower():
+                            stress_clusters.append({
+                                'lat': request.center_lat + np.random.uniform(-0.001, 0.001),
+                                'lon': request.center_lon + np.random.uniform(-0.001, 0.001),
+                                'stress_score': 0.5,
+                                'category': cluster_id,
+                                'severity': 'Moderate'
+                            })
+            except Exception as e:
+                logger.warning(f"[TakeAction] Stress detection failed: {e}")
+        
+        # Run LLM analysis
+        llm_result = run_take_action_llm(
+            category=request.category,
+            stress_clusters=stress_clusters,
+            indices_data=request.indices_timeseries or {},
+            farmer_profile=request.farmer_profile or {},
+            weather_data=request.weather_data or {}
+        )
+        
+        # Calculate overall stress score
+        stress_score = 0.0
+        if stress_clusters:
+            stress_score = sum(c.get('stress_score', 0) for c in stress_clusters) / len(stress_clusters)
+        
+        # Cluster distribution
+        cluster_dist = {}
+        for cluster in stress_clusters:
+            cat = cluster.get('severity', 'Unknown')
+            cluster_dist[cat] = cluster_dist.get(cat, 0) + 1
+        
+        return TakeActionResponse(
+            success=True,
+            category=request.category,
+            high_zones=llm_result.get('high_zones', []),
+            low_zones=llm_result.get('low_zones', []),
+            recommendations=llm_result.get('recommendations', ''),
+            risk_suggestions=llm_result.get('risk_suggestions', []),
+            detailed_analysis=llm_result.get('detailed_analysis', ''),
+            stress_score=stress_score,
+            cluster_distribution=cluster_dist
+        )
+        
+    except Exception as e:
+        logger.error(f"[TakeAction] Error: {e}")
+        logger.error(traceback.format_exc())
+        raise HTTPException(500, str(e))
+
+
 if __name__ == "__main__":
     import uvicorn
     uvicorn.run(app, host="0.0.0.0", port=7860)