Complete rewrite: direct API fetch, proper vegetation indices + cluster stress extraction

app.py

@@ -1,11 +1,11 @@
 """
-AGROW Agricultural Chatbot Service
-===================================
-AI-powered agricultural advisor with comprehensive context from:
-- SAR bands (VV, VH) and analysis
-- Sentinel-2 vegetation indices (all 13)
+AGROW Agricultural Chatbot Service - Comprehensive Context
+============================================================
+AI-powered agricultural advisor with COMPLETE context from:
+- SAR analysis (crop health, stress scores, recommendations)
+- Sentinel-2 vegetation indices (all from vegetation_indices_summary)
+- Sentinel-2 stress detection (cluster-wise patterns)
 - Weather data (current + forecast)
-- Clustering and stress patterns
 - Farmer profile from questionnaire
 - Field data from coordinates_quad
 """
@@ -14,6 +14,7 @@ import os
 import json
 import logging
 import uuid
+import requests
 from datetime import datetime
 from typing import Optional, List, Dict, Any
 import traceback
@@ -26,7 +27,6 @@ import asyncio
 import google.generativeai as genai
 
 from supabase_client import SupabaseClient
-from context_aggregator import ContextAggregator
 from prompts import PERSONA_DEFINITIONS, EXPERIENCE_MAP, TECH_COMFORT_MAP, INNOVATION_MAP, FARMING_GOAL_MAP
 
 # ============================================================================
@@ -43,6 +43,12 @@ print("=" * 50)
 print(f"===== Application Startup at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} =====")
 print("=" * 50)
 
+# ============================================================================
+# API ENDPOINTS
+# ============================================================================
+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")
+
 # ============================================================================
 # GEMINI SETUP
 # ============================================================================
@@ -55,9 +61,8 @@ else:
     model = None
     logger.warning("GEMINI_API_KEY not set - chatbot will return mock responses")
 
-# Supabase and Context Aggregator
+# Supabase
 supabase = SupabaseClient()
-context_aggregator = ContextAggregator(timeout=60)
 
 # ============================================================================
 # FASTAPI
@@ -65,7 +70,7 @@ context_aggregator = ContextAggregator(timeout=60)
 app = FastAPI(
     title="AGROW Chatbot Service",
     description="AI agricultural advisor with comprehensive satellite context",
-    version="2.0.0"
+    version="2.1.0"
 )
 
 app.add_middleware(
@@ -83,7 +88,7 @@ class ChatRequest(BaseModel):
     session_id: str
     message: str
     user_id: Optional[str] = None
-    field_id: Optional[str] = None  # Specific field to analyze
+    field_id: Optional[str] = None
 
 class ChatResponse(BaseModel):
     response: str
@@ -101,17 +106,6 @@ class SessionResponse(BaseModel):
     title: str
     created_at: str
 
-class MessageModel(BaseModel):
-    id: str
-    role: str
-    content: str
-    created_at: str
-
-class HistoryResponse(BaseModel):
-    session_id: str
-    messages: List[MessageModel]
-
-
 # ============================================================================
 # PERSONA DETECTION
 # ============================================================================
@@ -126,22 +120,18 @@ def detect_persona(questionnaire: Dict) -> str:
     goal = questionnaire.get("farming_goal", "Earn Income / Livelihood")
     role = questionnaire.get("role", "Farmer")
     
-    # Map to persona
     years = EXPERIENCE_MAP.get(experience, 3)
     tech_level = TECH_COMFORT_MAP.get(tech, "moderate")
     innovation_level = INNOVATION_MAP.get(innovation, "moderate")
-    goal_type = FARMING_GOAL_MAP.get(goal, "income")
     
-    # Role-based override
     if role == "Agricultural Officer":
         return "agricultural_officer"
     elif role in ["Agronomist", "Researcher"]:
         return "agronomist_researcher"
     
-    # Experience + innovation matrix
     if years < 3:
         return "new_farmer_tech_savvy" if tech_level == "advanced" else "new_farmer_basic_tech"
-    elif goal_type == "commercial":
+    elif FARMING_GOAL_MAP.get(goal) == "commercial":
         return "commercial_farmer"
     elif innovation_level == "innovative":
         return "experienced_farmer_innovative"
@@ -150,7 +140,7 @@ def detect_persona(questionnaire: Dict) -> str:
 
 
 # ============================================================================
-# FETCH COMPREHENSIVE CONTEXT
+# FETCH DATA DIRECTLY FROM APIs
 # ============================================================================
 def fetch_field_data(user_id: str, field_id: Optional[str] = None) -> Optional[Dict]:
     """Fetch field data from Supabase coordinates_quad."""
@@ -162,7 +152,6 @@ def fetch_field_data(user_id: str, field_id: Optional[str] = None) -> Optional[D
         
         if query.data and len(query.data) > 0:
             field = query.data[0]
-            # Calculate center point
             lats = [field.get(f"lat{i}", 0) for i in range(1, 5)]
             lons = [field.get(f"lon{i}", 0) for i in range(1, 5)]
             center_lat = sum(lats) / 4
@@ -173,11 +162,9 @@ def fetch_field_data(user_id: str, field_id: Optional[str] = None) -> Optional[D
                 "name": field.get("name", "My Field"),
                 "crop_type": field.get("crop_type", "Wheat"),
                 "area_acres": field.get("area_acres", 1.0),
-                "coordinates": {
-                    "center_lat": center_lat,
-                    "center_lon": center_lon,
-                    "bbox": [min(lons), min(lats), max(lons), max(lats)]
-                }
+                "center_lat": center_lat,
+                "center_lon": center_lon,
+                "bbox": [min(lons), min(lats), max(lons), max(lats)]
             }
     except Exception as e:
         logger.error(f"Error fetching field data: {e}")
@@ -196,260 +183,315 @@ def fetch_user_profile(user_id: str) -> Dict:
             return {
                 "name": profile.get("full_name", ""),
                 "location": profile.get("address", ""),
-                "questionnaire": profile.get("questionnaire_data", {})
+                "questionnaire": profile.get("questionnaire_data", {}) or {}
             }
     except Exception as e:
         logger.error(f"Error fetching user profile: {e}")
     return {"name": "", "location": "", "questionnaire": {}}
 
 
+def fetch_sar_data(bbox: List, crop_type: str) -> Optional[Dict]:
+    """Fetch SAR data directly from API."""
+    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": {}
+            },
+            timeout=60
+        )
+        if response.status_code == 200:
+            data = response.json()
+            logger.info(f"SAR raw data keys: {list(data.keys())}")
+            return data
+    except Exception as e:
+        logger.error(f"SAR fetch error: {e}")
+    return None
+
+
+def fetch_sentinel2_data(center_lat: float, center_lon: float, crop_type: str, field_hectares: float) -> Optional[Dict]:
+    """Fetch Sentinel-2 data directly from API."""
+    try:
+        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": {},
+                "skip_llm": True
+            },
+            timeout=90
+        )
+        if response.status_code == 200:
+            data = response.json()
+            logger.info(f"Sentinel-2 raw data keys: {list(data.keys())}")
+            return data
+    except Exception as e:
+        logger.error(f"Sentinel-2 fetch error: {e}")
+    return None
+
+
+def fetch_weather(lat: float, lon: float) -> Optional[Dict]:
+    """Fetch weather from Open-Meteo."""
+    try:
+        response = requests.get(
+            "https://api.open-meteo.com/v1/forecast",
+            params={
+                "latitude": lat,
+                "longitude": lon,
+                "current": "temperature_2m,relative_humidity_2m,precipitation,wind_speed_10m",
+                "daily": "temperature_2m_max,temperature_2m_min,precipitation_sum,precipitation_probability_max",
+                "timezone": "auto",
+                "forecast_days": 7
+            },
+            timeout=15
+        )
+        if response.status_code == 200:
+            data = response.json()
+            current = data.get("current", {})
+            daily = data.get("daily", {})
+            return {
+                "current_temp": current.get("temperature_2m"),
+                "current_humidity": current.get("relative_humidity_2m"),
+                "current_precipitation": current.get("precipitation"),
+                "forecast_max_temps": daily.get("temperature_2m_max", [])[:3],
+                "forecast_rain_prob": daily.get("precipitation_probability_max", [])[:3],
+                "forecast_precipitation": daily.get("precipitation_sum", [])[:3]
+            }
+    except Exception as e:
+        logger.error(f"Weather fetch error: {e}")
+    return None
+
+
+# ============================================================================
+# BUILD COMPREHENSIVE CONTEXT - DIRECT EXTRACTION
+# ============================================================================
 def build_comprehensive_context(user_id: str, field_id: Optional[str] = None) -> Dict:
-    """Build comprehensive context from all data sources."""
+    """Build comprehensive context with DIRECT API data extraction."""
     context = {
         "fetch_timestamp": datetime.now().isoformat(),
         "data_sources": []
     }
     
     # 1. Fetch field data
-    field_data = fetch_field_data(user_id, field_id)
-    if field_data:
-        context["field_info"] = field_data
-        context["data_sources"].append("coordinates_quad")
-        logger.info(f"Field data fetched: {field_data.get('name')}")
-    else:
-        return context  # Can't proceed without field
-    
-    # 2. Fetch user profile and questionnaire
-    user_profile = fetch_user_profile(user_id)
-    questionnaire = user_profile.get("questionnaire", {})
+    field = fetch_field_data(user_id, field_id)
+    if not field:
+        logger.warning("No field data found")
+        return context
+    
+    context["field"] = field
+    context["data_sources"].append("coordinates_quad")
+    logger.info(f"✓ Field: {field['name']} ({field['crop_type']})")
+    
+    # 2. Fetch user profile
+    profile = fetch_user_profile(user_id)
+    questionnaire = profile.get("questionnaire", {})
     persona = detect_persona(questionnaire)
-    
-    context["farmer_profile"] = {
-        "name": user_profile.get("name", ""),
-        "location": user_profile.get("location", ""),
+    context["farmer"] = {
+        "name": profile.get("name", ""),
         "persona": persona,
-        "questionnaire": questionnaire
+        "experience": questionnaire.get("experience", ""),
+        "tech_comfort": questionnaire.get("tech_comfort", ""),
+        "farming_goal": questionnaire.get("farming_goal", "")
     }
     context["data_sources"].append("user_profiles")
-    logger.info(f"Farmer persona detected: {persona}")
-    
-    # 3. Fetch satellite context using ContextAggregator
-    coordinates = field_data.get("coordinates", {})
-    crop_type = field_data.get("crop_type", "Wheat")
-    area_acres = field_data.get("area_acres", 1.0)
-    
-    satellite_context = context_aggregator.fetch_full_context(
-        coordinates=coordinates,
-        crop_type=crop_type,
-        area_acres=area_acres,
-        farmer_context={"profile": user_profile, "questionnaire": questionnaire}
-    )
-    
-    # Merge satellite data
-    if satellite_context.get("sar_bands"):
-        context["sar_bands"] = satellite_context["sar_bands"]
+    logger.info(f"✓ Farmer persona: {persona}")
+    
+    # 3. Fetch SAR data
+    sar_data = fetch_sar_data(field["bbox"], field["crop_type"])
+    if sar_data:
+        context["sar"] = {
+            "crop_health": sar_data.get("crop_health", "Unknown"),
+            "confidence": sar_data.get("confidence_score", 0),
+            "stress_score": sar_data.get("average_stress_score", 0),
+            "summary": sar_data.get("summary", ""),
+            "recommendations": sar_data.get("recommendations", []),
+            "health_summary": sar_data.get("health_summary", {}),
+            "stressed_patches": sar_data.get("stressed_patches", [])
+        }
         context["data_sources"].append("sar_api")
-    
-    if satellite_context.get("vegetation_indices"):
-        context["vegetation_indices"] = satellite_context["vegetation_indices"]
+        logger.info(f"✓ SAR: health={sar_data.get('crop_health')}, stress={sar_data.get('average_stress_score')}")
+    
+    # 4. Fetch Sentinel-2 data - EXTRACT DIRECTLY
+    s2_data = fetch_sentinel2_data(field["center_lat"], field["center_lon"], field["crop_type"], field["area_acres"] * 0.404686)
+    if s2_data:
+        # Extract vegetation_indices_summary -> contains 'indices' dict
+        vi_summary = s2_data.get("vegetation_indices_summary", {})
+        indices = vi_summary.get("indices", {})
+        
+        # Extract all vegetation indices
+        vi_extracted = {}
+        for name, stats in indices.items():
+            if isinstance(stats, dict):
+                latest = stats.get("latest", {})
+                vi_extracted[name.upper()] = {
+                    "mean": latest.get("mean"),
+                    "min": stats.get("min_in_field"),
+                    "max": stats.get("max_in_field"),
+                    "change": stats.get("change")
+                }
+        
+        if vi_extracted:
+            context["vegetation_indices"] = vi_extracted
+            logger.info(f"✓ Vegetation indices: {list(vi_extracted.keys())}")
+        
+        # Extract stress_detection - cluster-wise patterns
+        stress_det = s2_data.get("stress_detection", {})
+        if stress_det:
+            context["stress_detection"] = {
+                "overall_stress": stress_det.get("overall_stress_score"),
+                "stress_category": stress_det.get("stress_category"),
+                "cluster_summary": stress_det.get("cluster_summary", []),
+                "high_stress_zones": stress_det.get("high_stress_zones", []),
+                "recommendations": stress_det.get("recommendations", [])
+            }
+            logger.info(f"✓ Stress detection: {stress_det.get('stress_category')}")
+        
         context["data_sources"].append("sentinel2_api")
     
-    if satellite_context.get("soil_indicators"):
-        context["soil_indicators"] = satellite_context["soil_indicators"]
-    
-    if satellite_context.get("clustering"):
-        context["clustering"] = satellite_context["clustering"]
-    
-    if satellite_context.get("temporal_trends"):
-        context["temporal_trends"] = satellite_context["temporal_trends"]
-    
-    if satellite_context.get("historical_trends"):
-        context["historical_trends"] = satellite_context["historical_trends"]
-    
-    if satellite_context.get("weather"):
-        context["weather"] = satellite_context["weather"]
+    # 5. Fetch weather
+    weather = fetch_weather(field["center_lat"], field["center_lon"])
+    if weather:
+        context["weather"] = weather
         context["data_sources"].append("weather_api")
+        logger.info(f"✓ Weather: {weather.get('current_temp')}°C")
     
-    if satellite_context.get("stressed_patches"):
-        context["stressed_patches"] = satellite_context["stressed_patches"]
-    
-    if satellite_context.get("zone_analysis"):
-        context["zone_analysis"] = satellite_context["zone_analysis"]
-    
-    if satellite_context.get("anomalies"):
-        context["anomalies"] = satellite_context["anomalies"]
-    
-    logger.info(f"Context built from sources: {context['data_sources']}")
+    logger.info(f"Context complete: {context['data_sources']}")
     return context
 
 
 # ============================================================================
-# BUILD LLM PROMPT WITH CONTEXT
+# BUILD LLM PROMPT - COMPREHENSIVE
 # ============================================================================
 def build_llm_prompt(query: str, context: Dict, history: List[Dict] = None) -> str:
-    """Build comprehensive prompt for LLM with all context."""
+    """Build comprehensive prompt for LLM with ALL context data."""
     
-    # Get persona for response style
-    persona_key = context.get("farmer_profile", {}).get("persona", "experienced_farmer_traditional")
+    # Get persona
+    farmer = context.get("farmer", {})
+    persona_key = farmer.get("persona", "experienced_farmer_traditional")
     persona = PERSONA_DEFINITIONS.get(persona_key, PERSONA_DEFINITIONS["experienced_farmer_traditional"])
     
-    # Build context string
-    context_parts = []
+    # Build context sections
+    sections = []
     
-    # Field info
-    if context.get("field_info"):
-        field = context["field_info"]
-        context_parts.append(f"""## Field Information
+    # 1. Field Information
+    field = context.get("field", {})
+    if field:
+        sections.append(f"""## Field Information
 - Name: {field.get('name', 'Unknown')}
 - Crop: {field.get('crop_type', 'Unknown')}
 - Area: {field.get('area_acres', 0):.2f} acres
-- Location: {field.get('coordinates', {}).get('center_lat', 0):.4f}°N, {field.get('coordinates', {}).get('center_lon', 0):.4f}°E""")
+- Location: {field.get('center_lat', 0):.4f}°N, {field.get('center_lon', 0):.4f}°E""")
     
-    # Vegetation indices (all 13)
-    if context.get("vegetation_indices"):
-        vi = context["vegetation_indices"]
-        vi_lines = ["## Vegetation Indices (Sentinel-2)"]
+    # 2. Vegetation Indices (ALL extracted)
+    vi = context.get("vegetation_indices", {})
+    if vi:
+        vi_lines = ["## Vegetation Indices (Sentinel-2 Analysis)"]
         for name, data in vi.items():
-            if isinstance(data, dict):
-                mean = data.get("mean", data.get("value", "N/A"))
-                change = data.get("temporal_change", data.get("change", ""))
-                change_str = f" (Δ{change:+.3f})" if isinstance(change, (int, float)) else ""
-                vi_lines.append(f"- {name}: {mean:.4f}{change_str}" if isinstance(mean, float) else f"- {name}: {mean}")
-        context_parts.append("\n".join(vi_lines))
-    
-    # SAR Analysis (crop health from SAR data)
-    if context.get("sar_bands"):
-        sar = context["sar_bands"]
-        health = sar.get("crop_health", "unknown")
+            if isinstance(data, dict) and data.get("mean") is not None:
+                mean = data.get("mean", 0)
+                change = data.get("change", 0)
+                change_str = f" (Δ{change:+.4f})" if isinstance(change, (int, float)) else ""
+                vi_lines.append(f"- {name}: {mean:.4f}{change_str}")
+        if len(vi_lines) > 1:
+            sections.append("\n".join(vi_lines))
+    
+    # 3. SAR Analysis
+    sar = context.get("sar", {})
+    if sar:
         stress = sar.get("stress_score", 0)
         stress_str = f"{stress:.2f}" if isinstance(stress, (int, float)) else str(stress)
-        summary = sar.get("summary", "") or ""
-        summary_str = summary[:200] if summary else 'N/A'
-        recs = sar.get("recommendations", []) or []
-        rec_str = recs[0] if recs else 'No specific recommendations'
-        context_parts.append(f"""## SAR Crop Health Analysis
-- Overall Health: {health}
+        recommendations = sar.get("recommendations", [])
+        rec_list = "\n".join([f"  • {r}" for r in recommendations[:3]]) if recommendations else "  • No specific recommendations"
+        
+        sections.append(f"""## SAR Crop Health Analysis
+- Overall Health: {sar.get('crop_health', 'Unknown')}
 - Stress Score: {stress_str}
 - Confidence: {sar.get('confidence', 0)}%
-- Summary: {summary_str}
-- Top Recommendation: {rec_str}""")
-    
-    # Soil indicators
-    if context.get("soil_indicators"):
-        soil = context["soil_indicators"]
-        soil_lines = ["## Soil Indicators"]
-        for name, data in soil.items():
-            level = data.get("level", "unknown") if isinstance(data, dict) else data
-            value = data.get("value", "") if isinstance(data, dict) else ""
-            val_str = f" ({value:.2f})" if isinstance(value, float) else ""
-            soil_lines.append(f"- {name.replace('_', ' ').title()}: {level}{val_str}")
-        context_parts.append("\n".join(soil_lines))
-    
-    # Clustering
-    if context.get("clustering"):
-        cl = context["clustering"]
-        context_parts.append(f"""## Spatial Clustering
-- Clusters: {cl.get('num_clusters', 'N/A')}
-- Distribution: {json.dumps(cl.get('cluster_distribution', {}))}
-- Pattern: {cl.get('spatial_pattern', 'N/A')}""")
-    
-    # Temporal trends
-    if context.get("temporal_trends"):
-        tt = context["temporal_trends"]
-        context_parts.append(f"""## Temporal Trends
-- NDVI Trend: {tt.get('ndvi_trend', 'N/A')}
-- 7-day Change: {tt.get('7_day_change', 'N/A')}
-- 30-day Change: {tt.get('30_day_change', 'N/A')}
-- Anomaly: {tt.get('anomaly_detected', 'N/A')}""")
-    
-    # Weather
-    if context.get("weather"):
-        w = context["weather"]
-        current = w.get("current", {})
-        forecast = w.get("forecast_7_day", w.get("forecast", {}))
-        context_parts.append(f"""## Weather Data
-- Current: {current.get('temp', 'N/A')}°C, Humidity: {current.get('humidity', 'N/A')}%
-- 7-day Avg Temp: {w.get('7_day_avg', {}).get('temp', 'N/A')}°C
-- Precipitation: {w.get('7_day_avg', {}).get('total_precipitation', 'N/A')} mm
-- Forecast Rain Probability: {forecast.get('rain_probability', 'N/A')}%""")
-    
-    # Stressed patches
-    if context.get("stressed_patches") and len(context["stressed_patches"]) > 0:
-        patches = context["stressed_patches"][:3]  # Top 3
-        patch_lines = ["## Stress Zones Detected"]
-        for p in patches:
-            patch_lines.append(f"- {p.get('location', 'Unknown')}: Score {p.get('stress_score', 0):.2f}, Area: {p.get('area_percent', 0):.1f}%")
-        context_parts.append("\n".join(patch_lines))
-    
-    # Zone analysis
-    if context.get("zone_analysis"):
-        za = context["zone_analysis"]
-        if za.get("most_critical"):
-            mc = za["most_critical"]
-            context_parts.append(f"""## Priority Zone
-- Location: {mc.get('location', 'Unknown')}
-- Issue: {mc.get('issue', 'Unknown')}
-- Urgency: {mc.get('urgency', 'Medium')}""")
-    
-    # Farmer profile
-    if context.get("farmer_profile"):
-        fp = context["farmer_profile"]
-        q = fp.get("questionnaire", {})
-        context_parts.append(f"""## Farmer Profile
-- Experience: {q.get('experience', 'Unknown')}
-- Farming Goal: {q.get('farming_goal', 'Unknown')}
-- Tech Comfort: {q.get('tech_comfort', 'Unknown')}
-- Persona: {persona.get('description', '')}""")
-    
-    # Build conversation history
-    history_text = ""
-    if history and len(history) > 0:
-        recent = history[-4:]  # Last 2 exchanges
-        history_text = "\n## Recent Conversation\n"
-        for msg in recent:
-            role = "User" if msg.get("role") == "user" else "Assistant"
-            history_text += f"{role}: {msg.get('content', '')[:150]}...\n"
-    
-    # Combine into full prompt
-    context_str = "\n\n".join(context_parts)
-    
-    # Log context for debugging
-    logger.info(f"Context sections: {len(context_parts)}")
-    for i, part in enumerate(context_parts[:2]):  # Log first 2 sections
-        logger.info(f"Context[{i}]: {part[:100]}...")
+- Summary: {sar.get('summary', 'N/A')[:300]}
+- Recommendations:
+{rec_list}""")
+    
+    # 4. Stress Detection (Cluster-wise)
+    stress = context.get("stress_detection", {})
+    if stress:
+        clusters = stress.get("cluster_summary", [])
+        cluster_lines = []
+        for c in clusters[:5]:
+            if isinstance(c, dict):
+                cluster_lines.append(f"  • Cluster {c.get('id', '?')}: {c.get('stress_level', 'Unknown')} stress, {c.get('area_percent', 0):.1f}% of field")
+        
+        high_stress_zones = stress.get("high_stress_zones", [])
+        zone_lines = []
+        for z in high_stress_zones[:3]:
+            if isinstance(z, dict):
+                zone_lines.append(f"  • {z.get('location', 'Unknown')}: {z.get('severity', 'Unknown')}")
+        
+        sections.append(f"""## Stress Detection (Cluster Analysis)
+- Overall Stress: {stress.get('overall_stress', 'N/A')}
+- Category: {stress.get('stress_category', 'N/A')}
+- Clusters:
+{chr(10).join(cluster_lines) if cluster_lines else '  • No cluster data'}
+- High Stress Zones:
+{chr(10).join(zone_lines) if zone_lines else '  • No high stress zones detected'}""")
+    
+    # 5. Weather
+    weather = context.get("weather", {})
+    if weather:
+        sections.append(f"""## Weather Data
+- Current Temperature: {weather.get('current_temp', 'N/A')}°C
+- Humidity: {weather.get('current_humidity', 'N/A')}%
+- Current Precipitation: {weather.get('current_precipitation', 0)} mm
+- 3-Day Forecast Max Temps: {weather.get('forecast_max_temps', [])}
+- Rain Probability (next 3 days): {weather.get('forecast_rain_prob', [])}%""")
+    
+    # 6. Farmer Profile
+    sections.append(f"""## Farmer Profile
+- Experience: {farmer.get('experience', 'Unknown')}
+- Farming Goal: {farmer.get('farming_goal', 'Unknown')}
+- Tech Comfort: {farmer.get('tech_comfort', 'Unknown')}""")
+    
+    # Combine context
+    context_str = "\n\n".join(sections)
+    
+    # Log what we're passing
+    logger.info(f"Prompt sections: {len(sections)}")
+    for i, s in enumerate(sections[:3]):
+        logger.info(f"Section[{i}]: {s[:100]}...")
     
     prompt = f"""You are AGROW AI, an expert agricultural advisor analyzing REAL satellite data for an Indian farmer's field.
 
-# CRITICAL INSTRUCTION
-You MUST analyze the ACTUAL data provided below. DO NOT give generic farming advice.
-ALWAYS cite specific values from the analysis (e.g., "Your NDVI of 0.65 indicates...").
+# CRITICAL: USE THE ACTUAL DATA BELOW
+You MUST analyze and cite the specific values provided. DO NOT give generic advice.
+Reference exact numbers like "Your NDVI of 0.65..." or "The 0.10 stress score indicates..."
 
-# FARMER PROFILE
+# FARMER CONTEXT
 {persona.get('description', 'Experienced farmer')}
-Response Style: {persona.get('style', 'Practical')}
-Tone: {persona.get('tone', 'Friendly')}
-Focus: {persona.get('focus', 'Actionable advice')}
+Style: {persona.get('style', 'Practical')} | Tone: {persona.get('tone', 'Friendly')}
 
-# SATELLITE & FIELD DATA (ACTUAL VALUES FROM TODAY'S ANALYSIS)
+# SATELLITE ANALYSIS DATA (TODAY'S READINGS)
 {context_str}
-{history_text}
 
 # USER'S QUESTION
 {query}
 
 # RESPONSE REQUIREMENTS
-1. START by acknowledging the specific field and crop being analyzed
-2. CITE exact values from the data (NDVI, moisture levels, stress scores)
-3. EXPLAIN what these values mean for THIS specific crop
-4. PROVIDE 2-3 actionable recommendations based on the data
-5. If any stress zones detected, address them FIRST
-6. Keep response under 300 words
-7. Use simple language the farmer understands
-
-IMPORTANT: Your response MUST reference at least 3 specific data points from the analysis above.
+1. START with the field name and crop type
+2. CITE at least 3 specific data values from above
+3. If stress detected, address it with locations
+4. Give 2-3 actionable recommendations based on the data
+5. Keep response under 250 words
+6. Use simple farmer-friendly language
 
-Provide your analysis:"""
+Your analysis:"""
 
+    logger.info(f"Total prompt length: {len(prompt)} chars")
     return prompt
 
 
@@ -458,22 +500,16 @@ Provide your analysis:"""
 # ============================================================================
 def generate_response(user_message: str, history: List[Dict], context: Dict) -> tuple[str, List[str]]:
     """Generate AI response using comprehensive context."""
-    # Defensive null checks
     context = context or {}
     history = history or []
     context_used = context.get("data_sources", [])
     
     if model is None:
-        return f"Please configure GEMINI_API_KEY for real responses.", []
+        return "Please configure GEMINI_API_KEY for real responses.", []
     
     try:
-        # Build comprehensive prompt
         prompt = build_llm_prompt(user_message, context, history)
         
-        # Log context summary
-        logger.info(f"Context: {len(context_used)} sources, Prompt: {len(prompt)} chars")
-        
-        # Generate response
         response = model.generate_content(
             prompt,
             generation_config=genai.types.GenerationConfig(
@@ -486,6 +522,7 @@ def generate_response(user_message: str, history: List[Dict], context: Dict) ->
         
     except Exception as e:
         logger.error(f"Gemini error: {e}")
+        traceback.print_exc()
         return f"I apologize, but I encountered an error: {str(e)}", []
 
 
@@ -496,22 +533,17 @@ def generate_response(user_message: str, history: List[Dict], context: Dict) ->
 async def root():
     return {
         "service": "AGROW Chatbot Service",
-        "version": "2.0.0",
-        "features": ["comprehensive_context", "persona_based_responses", "satellite_analysis"]
+        "version": "2.1.0",
+        "features": ["comprehensive_context", "cluster_stress", "persona_based"]
     }
 
 @app.get("/health")
 async def health():
-    return {
-        "status": "healthy",
-        "gemini_configured": model is not None,
-        "supabase_configured": supabase.is_configured()
-    }
+    return {"status": "healthy", "gemini_configured": model is not None}
 
 
 @app.post("/session/new", response_model=SessionResponse)
 async def create_session(request: SessionRequest):
-    """Create a new chat session."""
     logger.info(f"Creating new session for user: {request.user_id}")
     try:
         session = supabase.create_session(
@@ -530,15 +562,12 @@ async def create_session(request: SessionRequest):
 
 @app.post("/chat", response_model=ChatResponse)
 async def chat(request: ChatRequest):
-    """Send a message and get AI response with full context."""
     logger.info(f"Chat request - Session: {request.session_id}")
     
     try:
-        # Load conversation history
         history = supabase.get_messages(request.session_id)
         
-        # Save user message
-        user_msg_id = supabase.add_message(
+        supabase.add_message(
             session_id=request.session_id,
             role="user",
             content=request.message
@@ -548,12 +577,9 @@ async def chat(request: ChatRequest):
         context = {}
         if request.user_id:
             context = build_comprehensive_context(request.user_id, request.field_id)
-            logger.info(f"Context built: {context.get('data_sources', [])}")
         
-        # Generate AI response
         response_text, context_used = generate_response(request.message, history, context)
         
-        # Save assistant response
         assistant_msg_id = supabase.add_message(
             session_id=request.session_id,
             role="assistant",
@@ -562,7 +588,6 @@ async def chat(request: ChatRequest):
         )
         
         supabase.update_session_timestamp(request.session_id)
-        logger.info(f"Response generated - {len(response_text)} chars")
         
         return ChatResponse(
             response=response_text,
@@ -574,13 +599,12 @@ async def chat(request: ChatRequest):
         
     except Exception as e:
         logger.error(f"Chat error: {e}")
-        logger.error(traceback.format_exc())
+        traceback.print_exc()
         raise HTTPException(500, str(e))
 
 
 @app.post("/chat/stream")
 async def chat_stream(request: ChatRequest):
-    """Stream chat response with full context."""
     logger.info(f"Stream chat - Session: {request.session_id}")
     
     try:
@@ -596,9 +620,7 @@ async def chat_stream(request: ChatRequest):
         context = {}
         if request.user_id:
             context = build_comprehensive_context(request.user_id, request.field_id)
-            logger.info(f"Context built: {context.get('data_sources', [])}")
         
-        # Generate response
         response_text, context_used = generate_response(request.message, history, context)
         
         assistant_msg_id = supabase.add_message(
@@ -611,15 +633,12 @@ async def chat_stream(request: ChatRequest):
         supabase.update_session_timestamp(request.session_id)
         
         async def stream_response():
-            # Send metadata
             yield f"data: {json.dumps({'type': 'metadata', 'session_id': request.session_id, 'message_id': assistant_msg_id, 'context_sources': context_used})}\n\n"
             
-            # Stream text in chunks
             for i in range(0, len(response_text), 15):
                 yield f"data: {json.dumps({'type': 'chunk', 'text': response_text[i:i+15]})}\n\n"
                 await asyncio.sleep(0.03)
             
-            # Done signal
             yield f"data: {json.dumps({'type': 'done', 'full_text': response_text})}\n\n"
         
         return StreamingResponse(stream_response(), media_type="text/event-stream")
@@ -631,36 +650,21 @@ async def chat_stream(request: ChatRequest):
 
 @app.get("/context/{user_id}")
 async def get_context(user_id: str, field_id: Optional[str] = None):
-    """Get the comprehensive context JSON for debugging."""
-    context = build_comprehensive_context(user_id, field_id)
-    return context
+    """Debug endpoint - returns full context JSON."""
+    return build_comprehensive_context(user_id, field_id)
 
 
-@app.get("/session/{session_id}/history", response_model=HistoryResponse)
+@app.get("/session/{session_id}/history")
 async def get_history(session_id: str):
-    """Get conversation history for a session."""
     try:
         messages = supabase.get_messages(session_id)
-        return HistoryResponse(
-            session_id=session_id,
-            messages=[
-                MessageModel(
-                    id=msg.get("id", ""),
-                    role=msg.get("role", ""),
-                    content=msg.get("content", ""),
-                    created_at=msg.get("created_at", "")
-                )
-                for msg in messages
-            ]
-        )
+        return {"session_id": session_id, "messages": messages}
     except Exception as e:
         raise HTTPException(500, str(e))
 
 
 @app.get("/sessions/{user_id}")
 async def list_sessions(user_id: str):
-    """List all chat sessions for a user."""
-    logger.info(f"Listing sessions for user: {user_id}")
     try:
         sessions = supabase.get_user_sessions(user_id)
         return {"user_id": user_id, "sessions": sessions, "count": len(sessions)}
@@ -670,8 +674,6 @@ async def list_sessions(user_id: str):
 
 @app.delete("/session/{session_id}")
 async def delete_session(session_id: str):
-    """Delete a chat session."""
-    logger.info(f"Deleting session: {session_id}")
     try:
         supabase.delete_session(session_id)
         return {"status": "deleted", "session_id": session_id}
@@ -681,5 +683,5 @@ async def delete_session(session_id: str):
 
 if __name__ == "__main__":
     import uvicorn
-    logger.info("Starting AGROW Chatbot Service v2.0")
+    logger.info("Starting AGROW Chatbot Service v2.1")
     uvicorn.run(app, host="0.0.0.0", port=7860)