Simplify chatbot: single LLM call, remove complex reasoning

app.py

@@ -1,9 +1,9 @@
 """
-AGROW Agricultural Chatbot Service
-===================================
+AGROW Agricultural Chatbot Service (Simplified)
+================================================
 AI-powered agricultural advisor with:
-- Multi-stage reasoning (Claim → Validate → Contradict → Confirm)
-- Priority-based context selection
+- Single LLM call (no multi-stage reasoning)
+- Multi-API key fallback
 - Supabase conversation storage
 """
 
@@ -23,9 +23,6 @@ from pydantic import BaseModel
 import asyncio
 
 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
@@ -40,301 +37,75 @@ logger = logging.getLogger("ChatbotService")
 # ============================================================================
 # GEMINI SETUP - Multi-API Key Fallback System
 # ============================================================================
-
-# Load multiple API keys (GEMINI_API_KEY_1 through GEMINI_API_KEY_5)
 def load_gemini_api_keys() -> List[str]:
     """Load all available Gemini API keys from environment."""
     keys = []
-    
-    # Primary key
     primary = os.environ.get("GEMINI_API_KEY")
     if primary:
         keys.append(primary)
-    
-    # Fallback keys 1-5
     for i in range(1, 6):
         key = os.environ.get(f"GEMINI_API_KEY_{i}")
         if key and key not in keys:
             keys.append(key)
-    
     return keys
 
 GEMINI_API_KEYS = load_gemini_api_keys()
-current_key_index = 0  # Track which key is currently in use
-
+current_key_index = 0
 logger.info(f"Loaded {len(GEMINI_API_KEYS)} Gemini API key(s)")
 
-# Try to discover available models at startup
+# Find working model
 def get_available_model(api_key: str):
-    """Try to find an available Gemini model with given API key."""
-    models_to_try = [
-        "gemini-2.0-flash",
-        "gemini-1.5-flash", 
-        "gemini-1.5-pro",
-        "gemini-pro",
-        "gemini-1.0-pro",
-    ]
-    
+    """Try to find an available Gemini model."""
+    models_to_try = ["gemini-2.0-flash", "gemini-1.5-flash", "gemini-1.5-pro"]
     if not api_key:
         return None, None
-    
     for model in models_to_try:
-        for version in ["v1beta", "v1"]:
-            url = f"https://generativelanguage.googleapis.com/{version}/models/{model}:generateContent"
-            try:
-                resp = requests.post(
-                    f"{url}?key={api_key}",
-                    json={"contents": [{"parts": [{"text": "test"}]}]},
-                    timeout=10
-                )
-                if resp.status_code in [200, 429]:
-                    logger.info(f"Found working model: {model} on {version}")
-                    return url, model
-            except:
-                pass
-    
+        url = f"https://generativelanguage.googleapis.com/v1beta/models/{model}:generateContent"
+        try:
+            resp = requests.post(
+                f"{url}?key={api_key}",
+                json={"contents": [{"parts": [{"text": "test"}]}]},
+                timeout=10
+            )
+            if resp.status_code in [200, 429]:
+                logger.info(f"Found working model: {model}")
+                return url, model
+        except:
+            pass
     return None, None
 
-# Initialize with first available key
 GEMINI_URL, GEMINI_MODEL = None, None
 if GEMINI_API_KEYS:
     GEMINI_URL, GEMINI_MODEL = get_available_model(GEMINI_API_KEYS[0])
-
-if GEMINI_URL:
     logger.info(f"Using Gemini model: {GEMINI_MODEL}")
-else:
-    GEMINI_URL = "https://generativelanguage.googleapis.com/v1beta/models/gemini-2.0-flash:generateContent"
-    logger.warning("Could not discover model, using default gemini-2.0-flash")
-
-if GEMINI_API_KEYS:
-    logger.info(f"Gemini API configured with {len(GEMINI_API_KEYS)} fallback key(s)")
-else:
-    logger.warning("No GEMINI_API_KEY set - chatbot will return mock responses")
 
 # Supabase client
 supabase = SupabaseClient()
 
 # ============================================================================
-# LLM CALLER WITH FALLBACK
+# SIMPLE SYSTEM PROMPT
 # ============================================================================
-def get_next_api_key() -> Optional[str]:
-    """Rotate to the next available API key."""
-    global current_key_index
-    if not GEMINI_API_KEYS:
-        return None
-    current_key_index = (current_key_index + 1) % len(GEMINI_API_KEYS)
-    logger.info(f"Rotated to API key {current_key_index + 1}/{len(GEMINI_API_KEYS)}")
-    return GEMINI_API_KEYS[current_key_index]
-
-
-# ============================================================================
-# STRICT RATE LIMITER - Maximum 5 API calls per minute
-# ============================================================================
-import time
-from collections import deque
-
-# Global rate limiter - tracks timestamps of API calls
-_api_call_timestamps: deque = deque(maxlen=100)  # Rolling window
-RATE_LIMIT_CALLS = 5  # Maximum calls per minute
-RATE_LIMIT_WINDOW = 60  # Window in seconds
-
-def check_rate_limit() -> bool:
-    """
-    Check if we're within rate limits.
-    Returns True if call is allowed, False if blocked.
-    """
-    global _api_call_timestamps
-    current_time = time.time()
-    
-    # Remove timestamps older than 1 minute
-    while _api_call_timestamps and current_time - _api_call_timestamps[0] > RATE_LIMIT_WINDOW:
-        _api_call_timestamps.popleft()
-    
-    # Check if we've exceeded the limit
-    if len(_api_call_timestamps) >= RATE_LIMIT_CALLS:
-        oldest_call = _api_call_timestamps[0]
-        wait_time = RATE_LIMIT_WINDOW - (current_time - oldest_call)
-        logger.warning(f"RATE LIMIT: {len(_api_call_timestamps)} calls in last minute. Wait {wait_time:.0f}s")
-        return False
-    
-    return True
-
-def record_api_call():
-    """Record an API call timestamp."""
-    _api_call_timestamps.append(time.time())
-    logger.info(f"API call recorded: {len(_api_call_timestamps)}/{RATE_LIMIT_CALLS} in last minute")
-
-def get_rate_limit_status() -> dict:
-    """Get current rate limit status."""
-    current_time = time.time()
-    # Clean old timestamps
-    while _api_call_timestamps and current_time - _api_call_timestamps[0] > RATE_LIMIT_WINDOW:
-        _api_call_timestamps.popleft()
-    
-    calls_remaining = RATE_LIMIT_CALLS - len(_api_call_timestamps)
-    if _api_call_timestamps:
-        reset_in = RATE_LIMIT_WINDOW - (current_time - _api_call_timestamps[0])
-    else:
-        reset_in = 0
-    
-    return {
-        "calls_made": len(_api_call_timestamps),
-        "calls_remaining": max(0, calls_remaining),
-        "reset_in_seconds": max(0, int(reset_in))
-    }
-
-
-def call_gemini_api(prompt: str) -> str:
-    """
-    Call Gemini API with fallback across multiple API keys.
-    
-    STRICT RATE LIMIT: Maximum 5 calls per minute.
-    Returns "RATE_LIMITED" if limit exceeded.
-    
-    Automatically rotates to next key on:
-    - 429 (rate limit)
-    - 403 (quota exceeded) 
-    - 500+ (server errors)
-    """
-    global current_key_index
-    
-    # STRICT RATE LIMIT CHECK - 5 calls/minute max
-    if not check_rate_limit():
-        logger.warning("RATE LIMIT EXCEEDED - returning fallback signal")
-        return "RATE_LIMITED"
-    
-    # Record ONE API call at the start (not per retry/rotation)
-    record_api_call()
-    
-    if not GEMINI_API_KEYS:
-        return "Please configure GEMINI_API_KEY for real responses."
-    
-    max_retries_per_key = 2
-    keys_tried = 0
-    
-    while keys_tried < len(GEMINI_API_KEYS):
-        current_key = GEMINI_API_KEYS[current_key_index]
-        url = f"{GEMINI_URL}?key={current_key}"
-        
-        for attempt in range(max_retries_per_key):
-            try:
-                response = requests.post(
-                    url,
-                    headers={"Content-Type": "application/json"},
-                    json={
-                        "contents": [{"parts": [{"text": prompt}]}],
-                        "generationConfig": {
-                            "temperature": 0.7,
-                            "maxOutputTokens": 2048,
-                        }
-                    },
-                    timeout=60
-                )
-                
-                if response.status_code == 200:
-                    data = response.json()
-                    if "candidates" in data and len(data["candidates"]) > 0:
-                        return data["candidates"][0]["content"]["parts"][0]["text"]
-                    return "No response generated."
-                
-                elif response.status_code in [400, 429, 403, 500, 502, 503]:
-                    # Rate limit, quota exceeded, or server error - try next key
-                    logger.warning(f"API key {current_key_index + 1} got {response.status_code}, rotating...")
-                    get_next_api_key()
-                    keys_tried += 1
-                    break  # Exit retry loop, try next key
-                    
-                else:
-                    logger.error(f"Gemini API error: {response.status_code}")
-                    return f"API error: {response.status_code}"
-                    
-            except requests.exceptions.Timeout:
-                logger.warning(f"Timeout on key {current_key_index + 1}, attempt {attempt + 1}")
-                if attempt == max_retries_per_key - 1:
-                    get_next_api_key()
-                    keys_tried += 1
-                continue
-                
-            except Exception as e:
-                logger.error(f"Gemini request error: {e}")
-                if attempt == max_retries_per_key - 1:
-                    get_next_api_key()
-                    keys_tried += 1
-                continue
-    
-    return "All API keys exhausted. Please try again later."
-
-
-# Initialize reasoning engine
-reasoning_engine = ReasoningEngine(llm_caller=call_gemini_api)
-intent_classifier = IntentClassifier()
-
-# Session history for conversation memory (follow-up awareness)
-# In production, this should be stored in Supabase/Redis, but for now use in-memory
-session_history: Dict[str, List[Dict]] = {}
-MAX_HISTORY_TURNS = 5
-
-
-def get_session_history(session_id: str) -> List[Dict]:
-    """Get recent conversation history for a session."""
-    return session_history.get(session_id, [])[-MAX_HISTORY_TURNS:]
-
-
-def add_to_session_history(session_id: str, role: str, content: str, 
-                           intent: str = None, diagnosis: str = None):
-    """Add a turn to session history for follow-up awareness."""
-    if session_id not in session_history:
-        session_history[session_id] = []
-    
-    turn = {
-        "role": role,
-        "content": content[:500],  # Truncate long content
-        "intent": intent,
-        "diagnosis": diagnosis[:200] if diagnosis else None
-    }
-    session_history[session_id].append(turn)
-    
-    # Keep only last N turns
-    if len(session_history[session_id]) > MAX_HISTORY_TURNS * 2:
-        session_history[session_id] = session_history[session_id][-MAX_HISTORY_TURNS:]
+SYSTEM_PROMPT = """You are AGROW AI, an expert agricultural advisor for Indian farmers.
 
+SPECIALIZATIONS:
+- Crop health analysis and diagnosis
+- Irrigation and water management
+- Pest and disease identification
+- Weather-based farming advice
+- Soil health recommendations
 
-def build_field_coordinates(field_data: Dict) -> Optional[Dict]:
-    """Build coordinates dict from field data with lat/lon corners."""
-    if not field_data:
-        return None
-    
-    lats = []
-    lons = []
-    for i in range(1, 5):
-        lat = field_data.get(f"lat{i}")
-        lon = field_data.get(f"lon{i}")
-        if lat is not None and lon is not None:
-            lats.append(float(lat))
-            lons.append(float(lon))
-    
-    if not lats or not lons:
-        return None
-    
-    center_lat = sum(lats) / len(lats)
-    center_lon = sum(lons) / len(lons)
-    
-    return {
-        "center_lat": round(center_lat, 6),
-        "center_lon": round(center_lon, 6),
-        "bbox": [min(lons), min(lats), max(lons), max(lats)]
-    }
+COMMUNICATION STYLE:
+- Use simple, practical language farmers understand
+- Give actionable, prioritized recommendations
+- Reference local conditions when available
+- Be concise but thorough
 
+When you lack specific data, provide general guidance based on the query."""
 
 # ============================================================================
-# FASTAPI
+# FASTAPI SETUP
 # ============================================================================
-app = FastAPI(
-    title="AGROW Chatbot Service",
-    description="AI agricultural advisor with multi-stage reasoning",
-    version="2.0.0"
-)
-
+app = FastAPI(title="AGROW Chatbot Service", version="2.0")
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -343,36 +114,28 @@ app.add_middleware(
     allow_headers=["*"],
 )
 
+print("=" * 50)
+print(f"===== Application Startup at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} =====")
+print("=" * 50)
+
 # ============================================================================
-# REQUEST/RESPONSE MODELS (Matching Developer Spec)
+# REQUEST/RESPONSE MODELS
 # ============================================================================
 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
+    field_id: Optional[str] = None
 
 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] = []
+    confidence: float = 0.8
 
 class ChatResponse(BaseModel):
-    """Full response matching developer spec."""
     response: ResponseContent
     session_id: str
     message_id: 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
@@ -383,16 +146,85 @@ class SessionResponse(BaseModel):
     title: str
     created_at: str
 
-class MessageModel(BaseModel):
-    id: str
-    role: str
-    content: str
-    created_at: str
+# ============================================================================
+# LLM CALL WITH FALLBACK
+# ============================================================================
+def get_next_api_key():
+    global current_key_index
+    current_key_index = (current_key_index + 1) % len(GEMINI_API_KEYS)
+    logger.info(f"Rotated to API key {current_key_index + 1}/{len(GEMINI_API_KEYS)}")
+    return GEMINI_API_KEYS[current_key_index]
 
-class HistoryResponse(BaseModel):
-    session_id: str
-    messages: List[MessageModel]
+def call_gemini_api(prompt: str) -> str:
+    """Call Gemini API with fallback across multiple API keys."""
+    global current_key_index
+    
+    if not GEMINI_API_KEYS:
+        return "Please configure GEMINI_API_KEY for real responses."
+    
+    keys_tried = 0
+    while keys_tried < len(GEMINI_API_KEYS):
+        current_key = GEMINI_API_KEYS[current_key_index]
+        url = f"{GEMINI_URL}?key={current_key}"
+        
+        try:
+            response = requests.post(
+                url,
+                headers={"Content-Type": "application/json"},
+                json={
+                    "contents": [{"parts": [{"text": prompt}]}],
+                    "generationConfig": {
+                        "temperature": 0.7,
+                        "maxOutputTokens": 1024,
+                    }
+                },
+                timeout=60
+            )
+            
+            if response.status_code == 200:
+                data = response.json()
+                if "candidates" in data and len(data["candidates"]) > 0:
+                    return data["candidates"][0]["content"]["parts"][0]["text"]
+                return "No response generated."
+            
+            elif response.status_code in [429, 403, 500, 502, 503]:
+                logger.warning(f"API key {current_key_index + 1} got {response.status_code}, rotating...")
+                get_next_api_key()
+                keys_tried += 1
+            else:
+                logger.error(f"Gemini API error: {response.status_code}")
+                return f"API error: {response.status_code}"
+                
+        except Exception as e:
+            logger.error(f"Gemini request error: {e}")
+            get_next_api_key()
+            keys_tried += 1
+    
+    return "All API keys exhausted. Please try again later."
+
+# ============================================================================
+# SIMPLE RESPONSE GENERATOR (SINGLE LLM CALL)
+# ============================================================================
+def generate_simple_response(query: str, history: List[Dict] = None) -> str:
+    """Generate response with a single LLM call."""
+    
+    # Build conversation context
+    history_text = ""
+    if history and len(history) > 0:
+        recent = history[-6:]  # Last 3 exchanges
+        for msg in recent:
+            role = "User" if msg.get("role") == "user" else "Assistant"
+            history_text += f"{role}: {msg.get('content', '')[:200]}\n"
+    
+    prompt = f"""{SYSTEM_PROMPT}
+
+{f"Recent conversation:{chr(10)}{history_text}" if history_text else ""}
+
+User Query: {query}
 
+Provide a helpful, actionable response:"""
+
+    return call_gemini_api(prompt)
 
 # ============================================================================
 # API ENDPOINTS
@@ -401,37 +233,27 @@ class HistoryResponse(BaseModel):
 async def root():
     return {
         "service": "AGROW Chatbot Service",
-        "version": "2.0.0",
-        "architecture": "Multi-Stage Reasoning (Claim→Validate→Contradict→Confirm)",
-        "endpoints": {
-            "/chat": "POST - Send message, get AI response with reasoning",
-            "/session/new": "POST - Create new chat session",
-            "/session/{id}/history": "GET - Get conversation history",
-            "/sessions/{user_id}": "GET - List user's sessions"
-        }
+        "version": "2.0-simple",
+        "status": "running"
     }
 
 @app.get("/health")
 async def health():
     return {
         "status": "healthy",
-        "gemini_configured": GEMINI_API_KEY is not None,
-        "gemini_model": GEMINI_MODEL,
-        "supabase_configured": supabase.is_configured()
+        "gemini_configured": GEMINI_URL is not None,
+        "api_keys_loaded": len(GEMINI_API_KEYS)
     }
 
-
 @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(
             user_id=request.user_id,
             title=request.title or "New Conversation"
         )
-        
         return SessionResponse(
             session_id=session["id"],
             title=session["title"],
@@ -441,15 +263,14 @@ async def create_session(request: SessionRequest):
         logger.error(f"Failed to create session: {e}")
         raise HTTPException(500, str(e))
 
-
 @app.post("/chat", response_model=ChatResponse)
 async def chat(request: ChatRequest):
-    """Send a message and get AI response with multi-stage reasoning."""
-    logger.info(f"Chat request - Session: {request.session_id}, Message: {request.message[:50]}...")
+    """Send a message and get AI response (single LLM call)."""
+    logger.info(f"Chat request - Session: {request.session_id}")
     
     try:
-        # Load conversation history
-        history = supabase.get_messages(request.session_id)
+        # Get conversation history
+        history = supabase.get_messages(request.session_id) or []
         
         # Save user message
         user_msg_id = supabase.add_message(
@@ -458,214 +279,25 @@ async def chat(request: ChatRequest):
             content=request.message
         )
         
-        # Build context - combine passed context with Supabase field data
-        context = request.field_context or {}
-        
-        # Fetch field data from Supabase if user_id provided
-        if request.user_id:
-            field_context = supabase.get_field_context(request.user_id)
-            if field_context:
-                context.update({
-                    "user_field": field_context,
-                    "crop_type": field_context.get("crop_type"),
-                    "field_name": field_context.get("field_name"),
-                    "area_acres": field_context.get("area_acres"),
-                    "coordinates": field_context.get("coordinates"),
-                })
-                logger.info(f"Field context loaded: {field_context.get('field_name')}, {field_context.get('crop_type')}")
-            
-            # Also get user profile
-            user_profile = supabase.get_user_profile(request.user_id)
-            if user_profile:
-                context["user_profile"] = user_profile
-            
-            # Get all user fields for comparison detection
-            all_user_fields = supabase.get_user_fields(request.user_id)
-            field_names = [f.get("name", "") for f in all_user_fields if f.get("name")]
-        else:
-            user_profile = None
-            all_user_fields = []
-            field_names = []
-        
-        # Create persona from user profile for tailored responses
-        from prompts import create_user_persona, format_weather_context, format_zone_context, format_trend_context, format_conversation_history
-        persona = create_user_persona(user_profile, all_user_fields)
-        context["persona"] = persona
-        logger.info(f"User persona: {persona.get('type')}")
-        
-        # Get conversation history for follow-up awareness
-        conv_history = get_session_history(request.session_id)
-        context["conversation_history"] = conv_history
-        if conv_history:
-            logger.info(f"Loaded {len(conv_history)} previous turns for context")
-        
-        # Detect intent first
-        intent = intent_classifier.classify(request.message)
-        logger.info(f"Intent: {intent['primary_intent']} ({intent['confidence']})")
-        
-        # Check if this is a field comparison query
-        is_comparison_query = intent_classifier.is_field_comparison_query(
-            request.message, field_names
-        )
-        mentioned_fields = intent_classifier.extract_field_names(
-            request.message, field_names
-        )
-        
-        if is_comparison_query and len(mentioned_fields) >= 1:
-            logger.info(f"Field comparison detected - fields: {mentioned_fields}")
-            context["comparison_requested"] = True
-            context["mentioned_fields"] = mentioned_fields
-            
-            # Fetch satellite data for each mentioned field
-            comparison_contexts = {}
-            for field_name in mentioned_fields:
-                field_data = next(
-                    (f for f in all_user_fields if f.get("name") == field_name), 
-                    None
-                )
-                if field_data:
-                    # Build coordinates from field data
-                    field_coords = build_field_coordinates(field_data)
-                    if field_coords:
-                        try:
-                            field_satellite = fetch_field_context(
-                                coordinates=field_coords,
-                                crop_type=field_data.get("crop_type", "Wheat"),
-                                area_acres=field_data.get("area_acres", 1.0),
-                                fetch_satellite=True
-                            )
-                            comparison_contexts[field_name] = {
-                                "field_info": field_data,
-                                "satellite_data": field_satellite
-                            }
-                            logger.info(f"Fetched data for comparison field: {field_name}")
-                        except Exception as e:
-                            logger.warning(f"Could not fetch data for {field_name}: {e}")
-            
-            context["comparison_fields"] = comparison_contexts
-        
-        # Fetch satellite data for technical queries (vegetation, water, nutrient intents)
-        satellite_intents = [
-            "vegetation_health", "water_stress", "nutrient_status", 
-            "pest_disease", "forecast_query", "zone_specific", "action_recommendation",
-            "field_comparison"  # Also fetch for comparison queries
-        ]
-        if (intent["primary_intent"] in satellite_intents and 
-            context.get("coordinates") and 
-            intent["confidence"] >= 0.3):  # Lowered threshold to 0.3
-            
-            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
-        # DEFAULT: Use simple mode (1 call) to conserve API quota
-        # Full reasoning (5 calls) only for: deep analysis, diagnosis, or explicit comparison
-        full_reasoning_keywords = [
-            "diagnose", "diagnosis", "deep analysis", "detailed", "compare fields",
-            "why is", "investigate", "root cause", "analyze thoroughly"
-        ]
-        message_lower = request.message.lower()
-        
-        use_full_reasoning = (
-            intent["confidence"] >= 0.7 and  # Raised from 0.4 - need high confidence
-            context and
-            intent["primary_intent"] not in ["general_query"] and
-            any(kw in message_lower for kw in full_reasoning_keywords)  # Explicit request needed
-        )
-        
-        if use_full_reasoning:
-            # Full multi-stage reasoning (5 API calls)
-            logger.info("Using multi-stage reasoning pipeline (explicit request)")
-            response_text, reasoning_trace = reasoning_engine.process_query(
-                query=request.message,
-                context=context
-            )
-            # 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 (1 API call) - DEFAULT
-            logger.info("Using simple response mode (API-efficient)")
-            response_text = simple_reason(
-                query=request.message,
-                context=context,
-                llm_caller=call_gemini_api
-            )
-            
-            # Check if rate limited or API exhausted - use fallback
-            if response_text in ["RATE_LIMITED", "API_EXHAUSTED"]:
-                logger.warning("Using fallback response due to rate limit")
-                response_text = generate_fallback_response(request.message, context)
-            
-            reasoning_trace = {
-                "mode": "simple",
-                "intent": intent,
-                "field_context": context.get("user_field") if context else None,
-                "rate_limit_status": get_rate_limit_status()
-            }
-            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"
-            )
+        # Generate response (SINGLE LLM CALL)
+        logger.info("Generating response (single LLM call)")
+        response_text = generate_simple_response(request.message, history)
         
         # Save assistant response
         assistant_msg_id = supabase.add_message(
             session_id=request.session_id,
             role="assistant",
-            content=response_text,
-            context_used=list(context_priority.get("priority_1", []))
-        )
-        
-        # Save to session history for follow-up awareness
-        add_to_session_history(
-            request.session_id, "user", request.message, 
-            intent=intent["primary_intent"]
-        )
-        add_to_session_history(
-            request.session_id, "assistant", response_text,
-            diagnosis=diagnosis
+            content=response_text
         )
         
-        # Update session timestamp
         supabase.update_session_timestamp(request.session_id)
-        
         logger.info(f"Response generated - {len(response_text)} chars")
         
-        # Build spec-compliant response
         return ChatResponse(
-            response=ResponseContent(
-                message=response_text,
-                confidence=confidence,
-                diagnosis=diagnosis
-            ),
+            response=ResponseContent(message=response_text),
             session_id=request.session_id,
             message_id=assistant_msg_id,
-            timestamp=datetime.now().isoformat(),
-            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
+            timestamp=datetime.now().isoformat()
         )
         
     except Exception as e:
@@ -673,300 +305,84 @@ async def chat(request: ChatRequest):
         logger.error(traceback.format_exc())
         raise HTTPException(500, str(e))
 
-
-# ============================================================================
-# STREAMING CHAT ENDPOINT (SSE)
-# ============================================================================
 @app.post("/chat/stream")
 async def chat_stream(request: ChatRequest):
-    """
-    Send a message and get AI response streamed via Server-Sent Events.
-    Provides typewriter-style text reveal for better UX.
-    """
+    """Streaming chat endpoint (also uses single LLM call, then streams)."""
     logger.info(f"Stream chat request - Session: {request.session_id}")
     
     try:
-        # Save user message first
-        user_msg_id = supabase.add_message(
+        history = supabase.get_messages(request.session_id) or []
+        
+        supabase.add_message(
             session_id=request.session_id,
             role="user",
             content=request.message
         )
         
-        # Build context (same as regular chat)
-        context = request.field_context or {}
+        # Generate full response first
+        response_text = generate_simple_response(request.message, history)
         
-        if request.user_id:
-            field_context = supabase.get_field_context(request.user_id)
-            if field_context:
-                context.update({
-                    "user_field": field_context,
-                    "crop_type": field_context.get("crop_type"),
-                    "field_name": field_context.get("field_name"),
-                    "area_acres": field_context.get("area_acres"),
-                    "coordinates": field_context.get("coordinates"),
-                })
-            
-            user_profile = supabase.get_user_profile(request.user_id)
-            if user_profile:
-                context["user_profile"] = user_profile
-            
-            all_user_fields = supabase.get_user_fields(request.user_id)
-        else:
-            user_profile = None
-            all_user_fields = []
-        
-        from prompts import create_user_persona
-        persona = create_user_persona(user_profile, all_user_fields)
-        context["persona"] = persona
-        
-        # Detect intent
-        intent = intent_classifier.classify(request.message)
-        logger.info(f"Stream - Intent: {intent['primary_intent']} ({intent['confidence']})")
-        
-        # Fetch satellite data if needed
-        satellite_intents = [
-            "vegetation_health", "water_stress", "nutrient_status", 
-            "pest_disease", "forecast_query", "zone_specific", "action_recommendation"
-        ]
-        if (intent["primary_intent"] in satellite_intents and 
-            context.get("coordinates") and 
-            intent["confidence"] >= 0.3):
-            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)
-            except Exception as e:
-                logger.warning(f"Could not fetch satellite data: {e}")
-        
-        # Determine reasoning mode - DEFAULT to simple (1 API call)
-        # Full reasoning (5 calls) only for explicit deep analysis requests
-        full_reasoning_keywords = [
-            "diagnose", "diagnosis", "deep analysis", "detailed", "compare fields",
-            "why is", "investigate", "root cause", "analyze thoroughly"
-        ]
-        message_lower = request.message.lower()
-        
-        use_full_reasoning = (
-            intent["confidence"] >= 0.7 and
-            context and
-            intent["primary_intent"] not in ["general_query"] and
-            any(kw in message_lower for kw in full_reasoning_keywords)
-        )
-        
-        # Get full response first (reasoning happens here)
-        if use_full_reasoning:
-            logger.info("Stream using multi-stage reasoning (explicit request)")
-            response_text, reasoning_trace = reasoning_engine.process_query(
-                query=request.message,
-                context=context
-            )
-            diagnosis = reasoning_trace.get("stages", {}).get("confirmation", {}).get("final")
-            confidence = reasoning_trace.get("stages", {}).get("confirmation", {}).get("confidence", 0.7)
-        else:
-            logger.info("Stream using simple response mode (API-efficient)")
-            response_text = simple_reason(
-                query=request.message,
-                context=context,
-                llm_caller=call_gemini_api
-            )
-            
-            # Check if rate limited - use fallback
-            if response_text in ["RATE_LIMITED", "API_EXHAUSTED"]:
-                logger.warning("Stream: Using fallback due to rate limit")
-                response_text = generate_fallback_response(request.message, context)
-            
-            reasoning_trace = {"mode": "simple", "intent": intent, "rate_limit": get_rate_limit_status()}
-            diagnosis = None
-            confidence = 0.5
-        
-        # Save assistant message
         assistant_msg_id = supabase.add_message(
             session_id=request.session_id,
             role="assistant",
             content=response_text
         )
         
-        # Update session history
-        add_to_session_history(request.session_id, "user", request.message, intent=intent["primary_intent"])
-        add_to_session_history(request.session_id, "assistant", response_text, diagnosis=diagnosis)
         supabase.update_session_timestamp(request.session_id)
         
-        # Generate followups
-        from prompts import generate_followup_questions
-        suggested_followups = generate_followup_questions(intent["primary_intent"], diagnosis or "general")
-        
-        # Stream the response in chunks
+        # Stream response in chunks
         async def generate_stream():
-            """Yield response chunks with delays for typewriter effect."""
-            chunk_size = 12  # Characters per chunk
-            delay = 0.04  # 40ms between chunks
+            chunk_size = 15
+            delay = 0.03
             
-            # First, send metadata
-            metadata = {
-                "type": "metadata",
-                "session_id": request.session_id,
-                "message_id": assistant_msg_id,
-                "confidence": confidence,
-                "diagnosis": diagnosis,
-                "suggested_followups": suggested_followups
-            }
-            yield f"data: {json.dumps(metadata)}\n\n"
+            # Send metadata
+            yield f"data: {json.dumps({'type': 'metadata', 'session_id': request.session_id, 'message_id': assistant_msg_id})}\n\n"
             
-            # Stream the text in chunks
+            # Stream text chunks
             for i in range(0, len(response_text), chunk_size):
-                chunk = response_text[i:i + chunk_size]
+                chunk = response_text[i:i+chunk_size]
                 yield f"data: {json.dumps({'type': 'chunk', 'text': chunk})}\n\n"
                 await asyncio.sleep(delay)
             
-            # Send completion signal
+            # Done signal
             yield f"data: {json.dumps({'type': 'done', 'full_text': response_text})}\n\n"
         
-        return StreamingResponse(
-            generate_stream(),
-            media_type="text/event-stream",
-            headers={
-                "Cache-Control": "no-cache",
-                "Connection": "keep-alive",
-                "X-Accel-Buffering": "no"  # Disable nginx buffering
-            }
-        )
+        return StreamingResponse(generate_stream(), media_type="text/event-stream")
         
     except Exception as e:
         logger.error(f"Stream chat error: {e}")
-        logger.error(traceback.format_exc())
-        
-        async def error_stream():
-            yield f"data: {json.dumps({'type': 'error', 'message': str(e)})}\n\n"
-        
-        return StreamingResponse(error_stream(), media_type="text/event-stream")
+        raise HTTPException(500, str(e))
 
-@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."""
-    logger.info(f"Loading history for session: {session_id}")
-    
     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:
-        logger.error(f"History error: {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)
-        }
+        return {"user_id": user_id, "sessions": sessions, "count": len(sessions)}
     except Exception as e:
-        logger.error(f"List sessions error: {e}")
         raise HTTPException(500, str(e))
 
-
 @app.delete("/session/{session_id}")
 async def delete_session(session_id: str):
-    """Delete a chat session and its messages."""
+    """Delete a chat session."""
     logger.info(f"Deleting session: {session_id}")
-    
     try:
         supabase.delete_session(session_id)
         return {"status": "deleted", "session_id": session_id}
     except Exception as e:
-        logger.error(f"Delete error: {e}")
         raise HTTPException(500, str(e))
 
-
-# Intent analysis endpoint (for debugging)
-@app.post("/analyze-intent")
-async def analyze_intent(request: Dict[str, str]):
-    """Analyze query intent without generating response."""
-    query = request.get("query", "")
-    intent = intent_classifier.classify(query)
-    return {
-        "query": query,
-        "intent": intent
-    }
-
-
-# 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")
+    logger.info("Starting AGROW Chatbot Service v2.0 (Simple)")
     uvicorn.run(app, host="0.0.0.0", port=7860)
-