Implement multi-stage reasoning architecture (Claim→Validate→Contradict→Confirm)

app.py

@@ -1,10 +1,10 @@
 """
 AGROW Agricultural Chatbot Service
 ===================================
-AI-powered agricultural advisor using Gemini LLM with:
-- Context from pipeline outputs (stress, NDVI, forecasts)
+AI-powered agricultural advisor with:
+- Multi-stage reasoning (Claim → Validate → Contradict → Confirm)
+- Priority-based context selection
 - Supabase conversation storage
-- Session management
 """
 
 import os
@@ -21,7 +21,8 @@ from fastapi.middleware.cors import CORSMiddleware
 from pydantic import BaseModel
 
 from supabase_client import SupabaseClient
-from prompts import SYSTEM_PROMPT, build_context_prompt
+from reasoning_engine import ReasoningEngine, simple_reason
+from intent_classifier import IntentClassifier
 
 # ============================================================================
 # LOGGING
@@ -53,17 +54,15 @@ def get_available_model():
         return None, None
     
     for model in models_to_try:
-        # Try v1beta first, then v1
         for version in ["v1beta", "v1"]:
             url = f"https://generativelanguage.googleapis.com/{version}/models/{model}:generateContent"
             try:
-                import requests
                 resp = requests.post(
                     f"{url}?key={GEMINI_API_KEY}",
                     json={"contents": [{"parts": [{"text": "test"}]}]},
                     timeout=10
                 )
-                if resp.status_code in [200, 429]:  # 200=OK, 429=rate limit (but model exists)
+                if resp.status_code in [200, 429]:
                     logger.info(f"Found working model: {model} on {version}")
                     return url, model
             except:
@@ -71,7 +70,6 @@ def get_available_model():
     
     return None, None
 
-# Find working model at startup
 GEMINI_URL, GEMINI_MODEL = get_available_model()
 if GEMINI_URL:
     logger.info(f"Using Gemini model: {GEMINI_MODEL}")
@@ -88,59 +86,7 @@ else:
 supabase = SupabaseClient()
 
 # ============================================================================
-# FASTAPI
-# ============================================================================
-app = FastAPI(
-    title="AGROW Chatbot Service",
-    description="AI agricultural advisor with conversation storage",
-    version="1.0.0"
-)
-
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# ============================================================================
-# REQUEST/RESPONSE MODELS
-# ============================================================================
-class ChatRequest(BaseModel):
-    session_id: str
-    message: str
-    user_id: Optional[str] = None
-    field_context: Optional[Dict[str, Any]] = None
-
-class ChatResponse(BaseModel):
-    response: str
-    session_id: str
-    message_id: str
-    context_used: List[str]
-    timestamp: str
-
-class SessionRequest(BaseModel):
-    user_id: str
-    title: Optional[str] = None
-
-class SessionResponse(BaseModel):
-    session_id: str
-    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]
-
-# ============================================================================
-# HELPER FUNCTIONS
+# LLM CALLER
 # ============================================================================
 def call_gemini_api(prompt: str) -> str:
     """Call Gemini API directly using REST with retry logic."""
@@ -148,10 +94,9 @@ def call_gemini_api(prompt: str) -> str:
         return "Please configure GEMINI_API_KEY for real responses."
     
     url = f"{GEMINI_URL}?key={GEMINI_API_KEY}"
-    logger.info(f"Calling Gemini API: {GEMINI_URL}")
     
     max_retries = 3
-    retry_delay = 2  # seconds
+    retry_delay = 2
     
     for attempt in range(max_retries):
         try:
@@ -164,31 +109,27 @@ def call_gemini_api(prompt: str) -> str:
                     }],
                     "generationConfig": {
                         "temperature": 0.7,
-                        "maxOutputTokens": 1024,
+                        "maxOutputTokens": 2048,
                     }
                 },
-                timeout=30
+                timeout=60
             )
             
-            logger.info(f"Gemini response status: {response.status_code}")
-            
             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 == 429:
-                # Rate limit - wait and retry
                 if attempt < max_retries - 1:
                     import time
                     wait_time = retry_delay * (2 ** attempt)
-                    logger.warning(f"Rate limited, waiting {wait_time}s before retry...")
+                    logger.warning(f"Rate limited, waiting {wait_time}s...")
                     time.sleep(wait_time)
                     continue
                 return "I'm currently busy. Please try again in a moment."
             else:
-                error_msg = response.text[:500]
-                logger.error(f"Gemini API error: {response.status_code} - {error_msg}")
+                logger.error(f"Gemini API error: {response.status_code}")
                 return f"API error: {response.status_code}"
                 
         except Exception as e:
@@ -200,40 +141,62 @@ def call_gemini_api(prompt: str) -> str:
     return "Failed after retries. Please try again."
 
 
-def generate_response(user_message: str, history: List[Dict], context: Optional[Dict] = None) -> tuple[str, List[str]]:
-    """Generate AI response using Gemini."""
-    context_used = []
-    
-    # Build context prompt if pipeline data available
-    context_prompt = ""
-    if context:
-        context_prompt = build_context_prompt(context)
-        context_used = list(context.keys())
-    
-    # Combine system prompt with context
-    full_system = SYSTEM_PROMPT
-    if context_prompt:
-        full_system += f"\n\n## Current Field Analysis:\n{context_prompt}"
-    
-    # Build conversation context
-    history_text = ""
-    for msg in history[-6:]:
-        role = "User" if msg.get("role") == "user" else "Assistant"
-        history_text += f"{role}: {msg.get('content', '')}\n"
-    
-    # Create full prompt
-    full_prompt = f"""{full_system}
+# Initialize reasoning engine
+reasoning_engine = ReasoningEngine(llm_caller=call_gemini_api)
+intent_classifier = IntentClassifier()
 
-## Previous Conversation:
-{history_text}
+# ============================================================================
+# FASTAPI
+# ============================================================================
+app = FastAPI(
+    title="AGROW Chatbot Service",
+    description="AI agricultural advisor with multi-stage reasoning",
+    version="2.0.0"
+)
 
-## Current Question:
-User: {user_message}
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
 
-## Your Response (as AGROW AI agricultural advisor):"""
-    
-    response_text = call_gemini_api(full_prompt)
-    return response_text, context_used
+# ============================================================================
+# REQUEST/RESPONSE MODELS
+# ============================================================================
+class ChatRequest(BaseModel):
+    session_id: str
+    message: str
+    user_id: Optional[str] = None
+    field_context: Optional[Dict[str, Any]] = None
+
+class ChatResponse(BaseModel):
+    response: str
+    session_id: str
+    message_id: str
+    context_used: List[str]
+    timestamp: str
+    reasoning_trace: Optional[Dict[str, Any]] = None
+
+class SessionRequest(BaseModel):
+    user_id: str
+    title: Optional[str] = None
+
+class SessionResponse(BaseModel):
+    session_id: str
+    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]
 
 # ============================================================================
 # API ENDPOINTS
@@ -242,9 +205,10 @@ User: {user_message}
 async def root():
     return {
         "service": "AGROW Chatbot Service",
-        "version": "1.0.0",
+        "version": "2.0.0",
+        "architecture": "Multi-Stage Reasoning (Claim→Validate→Contradict→Confirm)",
         "endpoints": {
-            "/chat": "POST - Send message, get AI response",
+            "/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"
@@ -256,6 +220,7 @@ async def health():
     return {
         "status": "healthy",
         "gemini_configured": GEMINI_API_KEY is not None,
+        "gemini_model": GEMINI_MODEL,
         "supabase_configured": supabase.is_configured()
     }
 
@@ -283,7 +248,7 @@ async def create_session(request: SessionRequest):
 
 @app.post("/chat", response_model=ChatResponse)
 async def chat(request: ChatRequest):
-    """Send a message and get AI response."""
+    """Send a message and get AI response with multi-stage reasoning."""
     logger.info(f"Chat request - Session: {request.session_id}, Message: {request.message[:50]}...")
     
     try:
@@ -297,13 +262,39 @@ async def chat(request: ChatRequest):
             content=request.message
         )
         
-        # Generate AI response
-        response_text, context_used = generate_response(
-            request.message, 
-            history,
-            request.field_context
+        # Detect intent first
+        intent = intent_classifier.classify(request.message)
+        logger.info(f"Intent: {intent['primary_intent']} ({intent['confidence']})")
+        
+        # Determine if we need full reasoning or simple response
+        use_full_reasoning = (
+            intent["confidence"] > 0.6 and 
+            request.field_context and
+            intent["primary_intent"] not in ["general_query"]
         )
         
+        if use_full_reasoning:
+            # Full multi-stage reasoning
+            logger.info("Using multi-stage reasoning pipeline")
+            response_text, reasoning_trace = reasoning_engine.process_query(
+                query=request.message,
+                context=request.field_context
+            )
+            context_used = list(reasoning_trace.get("evidence_summary", {}).get("primary", []))
+        else:
+            # Simple single-stage response
+            logger.info("Using simple response mode")
+            response_text = simple_reason(
+                query=request.message,
+                context=request.field_context or {},
+                llm_caller=call_gemini_api
+            )
+            reasoning_trace = {
+                "mode": "simple",
+                "intent": intent
+            }
+            context_used = list(request.field_context.keys()) if request.field_context else []
+        
         # Save assistant response
         assistant_msg_id = supabase.add_message(
             session_id=request.session_id,
@@ -322,7 +313,8 @@ async def chat(request: ChatRequest):
             session_id=request.session_id,
             message_id=assistant_msg_id,
             context_used=context_used,
-            timestamp=datetime.now().isoformat()
+            timestamp=datetime.now().isoformat(),
+            reasoning_trace=reasoning_trace
         )
         
     except Exception as e:
@@ -387,7 +379,19 @@ async def delete_session(session_id: str):
         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
+    }
+
+
 if __name__ == "__main__":
     import uvicorn
-    logger.info("Starting AGROW Chatbot Service")
+    logger.info("Starting AGROW Chatbot Service v2.0")
     uvicorn.run(app, host="0.0.0.0", port=7860)

intent_classifier.py

@@ -0,0 +1,138 @@
+"""
+Intent Classifier for Agricultural Chatbot
+==========================================
+Detects user intent to determine context priority.
+"""
+
+from typing import Dict, List, Tuple
+import re
+
+# Intent categories with keywords
+INTENT_PATTERNS = {
+    "vegetation_health": {
+        "keywords": ["yellow", "yellowing", "brown", "dying", "wilting", "healthy", "health",
+                     "crop health", "plant health", "leaf", "leaves", "chlorophyll", "green"],
+        "sub_intents": ["chlorophyll_issue", "nutrient_deficiency", "general_health"]
+    },
+    "water_stress": {
+        "keywords": ["water", "irrigation", "irrigate", "dry", "drought", "moisture", 
+                     "thirsty", "watering", "rain", "wet"],
+        "sub_intents": ["drought_stress", "overwatering", "irrigation_timing"]
+    },
+    "nutrient_status": {
+        "keywords": ["fertilizer", "nutrient", "nitrogen", "phosphorus", "potassium",
+                     "npk", "deficiency", "feeding", "feed"],
+        "sub_intents": ["nitrogen_deficiency", "nutrient_excess", "fertilizer_timing"]
+    },
+    "pest_disease": {
+        "keywords": ["pest", "disease", "insect", "bug", "infection", "fungus",
+                     "blight", "rot", "spots", "holes", "eating"],
+        "sub_intents": ["pest_damage", "fungal_disease", "bacterial_issue"]
+    },
+    "forecast_query": {
+        "keywords": ["forecast", "predict", "future", "next week", "tomorrow",
+                     "will", "expect", "trend", "coming days"],
+        "sub_intents": ["growth_forecast", "stress_prediction", "weather_impact"]
+    },
+    "zone_specific": {
+        "keywords": ["area", "zone", "patch", "section", "part", "corner",
+                     "northeast", "northwest", "southeast", "southwest", "north", "south"],
+        "sub_intents": ["zone_diagnosis", "zone_comparison"]
+    },
+    "action_recommendation": {
+        "keywords": ["what should", "how to", "fix", "solve", "recommend", "advice",
+                     "help", "do", "action", "steps", "treatment"],
+        "sub_intents": ["immediate_action", "long_term_plan"]
+    },
+    "comparison": {
+        "keywords": ["compare", "better", "worse", "change", "changed", "difference",
+                     "last week", "before", "improvement", "decline"],
+        "sub_intents": ["temporal_comparison", "zone_comparison"]
+    },
+    "general_query": {
+        "keywords": ["what", "how", "why", "tell", "about", "explain"],
+        "sub_intents": ["general_info"]
+    }
+}
+
+
+class IntentClassifier:
+    """Classifies user queries into agricultural intent categories."""
+    
+    def __init__(self):
+        self.patterns = INTENT_PATTERNS
+    
+    def classify(self, query: str) -> Dict:
+        """
+        Classify the intent of a user query.
+        
+        Returns:
+            {
+                "primary_intent": str,
+                "sub_intents": List[str],
+                "confidence": float,
+                "matched_keywords": List[str]
+            }
+        """
+        query_lower = query.lower()
+        intent_scores = {}
+        matched_keywords = {}
+        
+        # Score each intent based on keyword matches
+        for intent, config in self.patterns.items():
+            keywords = config["keywords"]
+            matches = [kw for kw in keywords if kw in query_lower]
+            
+            if matches:
+                # Score based on number and specificity of matches
+                score = len(matches) * 0.2
+                # Boost for longer, more specific matches
+                for match in matches:
+                    score += len(match) * 0.01
+                
+                intent_scores[intent] = min(score, 1.0)
+                matched_keywords[intent] = matches
+        
+        if not intent_scores:
+            # Default to general query
+            return {
+                "primary_intent": "general_query",
+                "sub_intents": ["general_info"],
+                "confidence": 0.5,
+                "matched_keywords": []
+            }
+        
+        # Get highest scoring intent
+        primary_intent = max(intent_scores, key=intent_scores.get)
+        confidence = intent_scores[primary_intent]
+        
+        # Get sub-intents
+        sub_intents = self._detect_sub_intents(query_lower, primary_intent)
+        
+        return {
+            "primary_intent": primary_intent,
+            "sub_intents": sub_intents,
+            "confidence": round(confidence, 2),
+            "matched_keywords": matched_keywords.get(primary_intent, [])
+        }
+    
+    def _detect_sub_intents(self, query: str, primary_intent: str) -> List[str]:
+        """Detect more specific sub-intents within the primary intent."""
+        sub_intents = []
+        config = self.patterns.get(primary_intent, {})
+        
+        # Add base sub-intents
+        if config.get("sub_intents"):
+            sub_intents.append(config["sub_intents"][0])
+        
+        # Detect additional context
+        if "why" in query:
+            sub_intents.append("causal_analysis")
+        if "how much" in query or "how many" in query:
+            sub_intents.append("quantitative")
+        if "when" in query:
+            sub_intents.append("temporal")
+        if "where" in query:
+            sub_intents.append("spatial")
+        
+        return sub_intents if sub_intents else ["general"]

priority_mapper.py

@@ -0,0 +1,165 @@
+"""
+Priority Context Mapper for Agricultural Chatbot
+=================================================
+Maps detected intents to prioritized context selection.
+"""
+
+from typing import Dict, List, Any, Optional
+
+# Intent to Context Priority Mapping
+INTENT_CONTEXT_PRIORITIES = {
+    "vegetation_health": {
+        "priority_1": ["NDVI", "EVI", "NDRE", "RECI", "temporal_trends.NDVI"],
+        "priority_2": ["clustering.stressed_patches", "anomalies", "PSRI"],
+        "priority_3": ["weather.temperature", "SMI", "B05", "B08"],
+        "priority_4": ["SAR.VV", "previous_analysis", "farmer_actions"]
+    },
+    "water_stress": {
+        "priority_1": ["SMI", "NDWI", "SAR.VV", "SAR.VH"],
+        "priority_2": ["temporal_trends.SMI", "weather.precipitation", "weather.evapotranspiration"],
+        "priority_3": ["NDVI", "clustering.moisture_clusters", "B11", "B12"],
+        "priority_4": ["farmer_actions.irrigation", "forecast.rain", "previous_analysis"]
+    },
+    "nutrient_status": {
+        "priority_1": ["NDRE", "RECI", "MCARI", "B05", "B06", "B07"],
+        "priority_2": ["NDVI", "EVI", "temporal_trends.NDRE"],
+        "priority_3": ["SMI", "SFI", "clustering.nutrient_clusters"],
+        "priority_4": ["farmer_actions.fertilizer", "weather", "previous_analysis"]
+    },
+    "pest_disease": {
+        "priority_1": ["anomalies", "PSRI", "PRI", "spatial_patterns.hotspots"],
+        "priority_2": ["NDVI", "temporal_trends.sudden_changes", "clustering.outliers"],
+        "priority_3": ["weather.humidity", "B04", "B05"],
+        "priority_4": ["farmer_actions.spraying", "previous_analysis", "historical_issues"]
+    },
+    "zone_specific": {
+        "priority_1": ["clustering.zone_stats", "patch_assignments", "spatial_embeddings"],
+        "priority_2": ["anomalies.in_zone", "all_indices.zone_values"],
+        "priority_3": ["temporal_trends.zone_specific"],
+        "priority_4": ["previous_analysis.zone_notes", "farmer_actions.zone_specific"]
+    },
+    "forecast_query": {
+        "priority_1": ["forecast.predictions", "temporal_trends.all", "weather.forecast"],
+        "priority_2": ["NDVI", "SMI", "current_stress_level"],
+        "priority_3": ["historical_patterns", "growth_stage"],
+        "priority_4": ["farmer_actions.planned", "previous_analysis"]
+    },
+    "action_recommendation": {
+        "priority_1": ["stress_summary", "NDVI", "SMI", "anomalies"],
+        "priority_2": ["weather.current", "weather.forecast"],
+        "priority_3": ["clustering.priority_zones", "temporal_trends"],
+        "priority_4": ["farmer_actions", "previous_analysis", "recommendations_history"]
+    },
+    "comparison": {
+        "priority_1": ["temporal_trends.all", "historical.NDVI", "historical.SMI"],
+        "priority_2": ["change_detection", "improvement_metrics"],
+        "priority_3": ["weather.historical", "farmer_actions.historical"],
+        "priority_4": ["previous_analysis", "baseline_values"]
+    },
+    "general_query": {
+        "priority_1": ["NDVI", "stress_summary", "weather.current"],
+        "priority_2": ["SMI", "anomalies", "clustering.summary"],
+        "priority_3": ["temporal_trends", "forecast"],
+        "priority_4": ["farmer_actions", "previous_analysis"]
+    }
+}
+
+
+class PriorityContextMapper:
+    """Maps intents to prioritized context for selective retrieval."""
+    
+    def __init__(self):
+        self.priority_map = INTENT_CONTEXT_PRIORITIES
+    
+    def get_context_priorities(self, intent: str) -> Dict[str, List[str]]:
+        """Get context priorities for a given intent."""
+        return self.priority_map.get(intent, self.priority_map["general_query"])
+    
+    def extract_priority_context(
+        self, 
+        intent: str, 
+        full_context: Dict[str, Any],
+        priority_levels: List[int] = [1, 2, 3, 4]
+    ) -> Dict[str, Dict[str, Any]]:
+        """
+        Extract context based on priority levels.
+        
+        Args:
+            intent: Detected intent
+            full_context: Complete context data
+            priority_levels: Which priority levels to include
+            
+        Returns:
+            {
+                "priority_1": {...},
+                "priority_2": {...},
+                ...
+            }
+        """
+        priorities = self.get_context_priorities(intent)
+        result = {}
+        
+        for level in priority_levels:
+            key = f"priority_{level}"
+            if key in priorities:
+                result[key] = self._extract_fields(
+                    full_context, 
+                    priorities[key]
+                )
+        
+        return result
+    
+    def _extract_fields(
+        self, 
+        context: Dict[str, Any], 
+        field_paths: List[str]
+    ) -> Dict[str, Any]:
+        """Extract specific fields from context using dot notation paths."""
+        extracted = {}
+        
+        for path in field_paths:
+            value = self._get_nested_value(context, path)
+            if value is not None:
+                # Use last part of path as key for simplicity
+                key = path.split(".")[-1]
+                extracted[key] = value
+        
+        return extracted
+    
+    def _get_nested_value(self, data: Dict, path: str) -> Any:
+        """Get nested value using dot notation (e.g., 'weather.temperature')."""
+        keys = path.split(".")
+        current = data
+        
+        for key in keys:
+            if isinstance(current, dict) and key in current:
+                current = current[key]
+            else:
+                return None
+        
+        return current
+    
+    def build_staged_context(
+        self,
+        intent: str,
+        full_context: Dict[str, Any]
+    ) -> Dict[str, Any]:
+        """
+        Build context organized by reasoning stages.
+        
+        Returns:
+            {
+                "claim_context": {...},      # Priority 1
+                "validate_context": {...},   # Priority 2
+                "contradict_context": {...}, # Priority 3
+                "confirm_context": {...}     # Priority 4
+            }
+        """
+        priority_context = self.extract_priority_context(intent, full_context)
+        
+        return {
+            "claim_context": priority_context.get("priority_1", {}),
+            "validate_context": priority_context.get("priority_2", {}),
+            "contradict_context": priority_context.get("priority_3", {}),
+            "confirm_context": priority_context.get("priority_4", {})
+        }

prompts.py

@@ -1,109 +1,184 @@
 """
-LLM Prompts for Agricultural Advisor
-=====================================
-System prompts and context builders for Gemini.
+LLM Prompts for Multi-Stage Reasoning
+======================================
+Prompts for each stage: Claim → Validate → Contradict → Confirm
 """
 
-SYSTEM_PROMPT = """You are AGROW AI, an expert agricultural advisor for farmers in India. You help farmers understand their crop health, soil conditions, and provide actionable recommendations.
-
-## Your Expertise:
-- Crop stress analysis using satellite imagery
-- Soil health interpretation (N, P, K, moisture)
-- Vegetation indices (NDVI, NDWI, EVI, SAVI)
-- Weather impact on farming
-- Pest and disease identification
-- Irrigation recommendations
-- Fertilizer application timing
-- Harvest optimization
-
-## Communication Style:
-- Be warm, supportive, and encouraging
-- Use simple language (assume farmer may not know technical terms)
-- When using technical terms, explain them briefly
-- Give practical, actionable advice
-- Consider Indian farming context (seasons, crops, practices)
+# =============================================================================
+# SYSTEM PROMPT (Base context)
+# =============================================================================
+
+SYSTEM_PROMPT = """You are AGROW AI, an expert agricultural advisor for farmers in India.
+
+You specialize in:
+- Satellite imagery interpretation (Sentinel-2, SAR data)
+- Vegetation indices analysis (NDVI, NDRE, EVI, SMI, etc.)
+- Crop stress diagnosis (water, nutrient, pest/disease)
+- Climate-smart farming recommendations
+- Regional crop knowledge (wheat, rice, cotton, sugarcane, pulses, etc.)
+
+Communication Style:
+- Use simple, practical language farmers can understand
+- Mention specific numbers from data when available
+- Give actionable recommendations
+- Reference local conditions when possible
 - Be concise but thorough
 
-## Response Format:
-- Start with a direct answer to the question
-- Provide 2-3 specific recommendations when relevant
-- End with encouragement or a helpful tip
-- Use bullet points for lists
+When you lack specific data, acknowledge it and give general guidance."""
 
-## Safety:
-- Never recommend chemicals without proper precautions
-- Suggest consulting local agricultural officers for serious issues
-- Recommend soil testing before major fertilizer decisions
-"""
+# =============================================================================
+# STAGE 1: CLAIM PROMPT
+# =============================================================================
+
+CLAIM_PROMPT = """You are analyzing agricultural satellite data to diagnose crop issues.
+
+USER QUERY: {query}
+
+AVAILABLE EVIDENCE (Primary indicators only):
+{priority_1_context}
+
+Based ONLY on this primary evidence:
+1. State your initial hypothesis about what's happening
+2. Cite specific values that support your hypothesis  
+3. Rate your confidence (0.0 to 1.0)
+
+Respond in JSON format:
+{{
+    "initial_claim": "Your hypothesis in 1-2 sentences",
+    "hypothesis": "single_word_label",
+    "evidence_cited": ["index1: value", "index2: value"],
+    "confidence": 0.X,
+    "uncertainties": ["what you're unsure about"]
+}}"""
+
+# =============================================================================
+# STAGE 2: VALIDATE PROMPT
+# =============================================================================
+
+VALIDATE_PROMPT = """You previously hypothesized: {previous_hypothesis}
+Initial confidence: {previous_confidence}
+
+ADDITIONAL SUPPORTING EVIDENCE:
+{priority_2_context}
+
+Does this new evidence:
+1. CONFIRM your hypothesis? (increases confidence)
+2. WEAKEN your hypothesis? (decreases confidence)
+3. Add SPATIAL context? (where is the issue concentrated?)
+
+Respond in JSON format:
+{{
+    "validation_result": "confirmed|weakened|neutral",
+    "confidence_updated": 0.X,
+    "spatial_notes": "location details if any",
+    "reasoning": "why confidence changed"
+}}"""
+
+# =============================================================================
+# STAGE 3: CONTRADICT PROMPT
+# =============================================================================
+
+CONTRADICT_PROMPT = """CURRENT HYPOTHESIS: {hypothesis} (confidence: {confidence})
+
+YOUR TASK: Actively look for evidence that CONTRADICTS this hypothesis.
+
+ALTERNATIVE CAUSAL FACTORS TO CONSIDER:
+{priority_3_context}
+
+Questions to answer:
+1. Could something ELSE explain the symptoms?
+2. Is there evidence that contradicts the current hypothesis?
+3. What's an alternative explanation?
+
+Respond in JSON format:
+{{
+    "contradiction_found": true|false,
+    "contradicting_evidence": ["evidence that doesn't fit"],
+    "alternative_hypothesis": "alternative explanation",
+    "alternative_confidence": 0.X,
+    "reasoning": "why alternative might be correct"
+}}"""
+
+# =============================================================================
+# STAGE 4: CONFIRM PROMPT
+# =============================================================================
+
+CONFIRM_PROMPT = """COMPETING HYPOTHESES:
+1. {hypothesis_1} (confidence: {conf_1})
+2. {hypothesis_2} (confidence: {conf_2})
+
+FINAL VALIDATION DATA:
+{priority_4_context}
 
+Determine the FINAL diagnosis by:
+1. Weighing evidence for each hypothesis
+2. Considering farmer's recent actions
+3. Checking consistency with previous analyses
+4. Identifying the ROOT CAUSE vs symptoms
+
+Respond in JSON format:
+{{
+    "final_diagnosis": "clear diagnosis statement",
+    "confidence": 0.X,
+    "causal_chain": "A → B → C → symptom",
+    "root_cause": "the underlying cause",
+    "symptoms": ["observable symptoms"],
+    "recommendation": "what to do next"
+}}"""
+
+# =============================================================================
+# RESPONSE GENERATION PROMPT
+# =============================================================================
+
+RESPONSE_PROMPT = """Based on this diagnostic analysis, generate a helpful response for the farmer.
+
+USER QUERY: {query}
+
+DIAGNOSIS RESULT:
+{diagnosis}
+
+EVIDENCE SUMMARY:
+{evidence}
+
+Generate a response that:
+1. Directly answers the farmer's question
+2. Explains the diagnosis in simple terms
+3. Cites key evidence (with numbers)
+4. Provides actionable recommendations
+5. Is concise but complete (3-5 paragraphs max)
+
+Use emojis sparingly for visual clarity (📊 for data, 🔬 for analysis, ✅ for recommendations).
+
+Respond in natural language (not JSON)."""
+
+# =============================================================================
+# HELPER FUNCTIONS
+# =============================================================================
 
 def build_context_prompt(context: dict) -> str:
-    """Build context prompt from pipeline analysis data."""
-    parts = []
-    
-    # Stress Analysis
-    if "stress_score" in context:
-        score = context["stress_score"]
-        level = "low" if score < 0.3 else "moderate" if score < 0.6 else "high"
-        parts.append(f"• Crop Stress Level: {level} ({score:.2f}/1.0)")
+    """Convert context dict to readable string for LLM."""
+    if not context:
+        return "No specific data available."
     
-    # Vegetation Indices
-    if "ndvi" in context:
-        ndvi = context["ndvi"]
-        health = "excellent" if ndvi > 0.7 else "good" if ndvi > 0.5 else "concerning" if ndvi > 0.3 else "poor"
-        parts.append(f"• NDVI (Plant Health): {ndvi:.3f} - {health}")
+    lines = []
+    for key, value in context.items():
+        if isinstance(value, dict):
+            lines.append(f"**{key}**:")
+            for k, v in value.items():
+                lines.append(f"  - {k}: {v}")
+        elif isinstance(value, list):
+            lines.append(f"**{key}**: {', '.join(str(v) for v in value)}")
+        else:
+            lines.append(f"**{key}**: {value}")
     
-    if "ndwi" in context:
-        ndwi = context["ndwi"]
-        water = "adequate" if ndwi > 0 else "stressed"
-        parts.append(f"• NDWI (Water Content): {ndwi:.3f} - {water}")
-    
-    if "evi" in context:
-        parts.append(f"• EVI (Vegetation Vigor): {context['evi']:.3f}")
-    
-    # Soil Data
-    if "soil" in context:
-        soil = context["soil"]
-        parts.append(f"• Soil Moisture: {soil.get('moisture', 'N/A')}")
-        parts.append(f"• Soil NPK: N={soil.get('nitrogen', 'N/A')}, P={soil.get('phosphorus', 'N/A')}, K={soil.get('potassium', 'N/A')}")
-    
-    # Forecast
-    if "forecast" in context:
-        fc = context["forecast"]
-        parts.append(f"• 20-day Forecast: {fc.get('trend', 'stable')}")
-    
-    # Field Info
-    if "field_name" in context:
-        parts.append(f"• Field: {context['field_name']}")
-    
-    if "crop_type" in context:
-        parts.append(f"• Crop: {context['crop_type']}")
-    
-    if "area" in context:
-        parts.append(f"• Area: {context['area']} acres")
-    
-    # Clusters/Zones
-    if "zones" in context:
-        zones = context["zones"]
-        parts.append(f"• Field Zones: {len(zones)} distinct areas identified")
-        for i, zone in enumerate(zones[:3]):  # Max 3 zones
-            parts.append(f"  - Zone {i+1}: {zone.get('condition', 'N/A')}")
-    
-    # Weather
-    if "weather" in context:
-        w = context["weather"]
-        parts.append(f"• Current Weather: {w.get('condition', 'N/A')}, {w.get('temp', 'N/A')}°C")
-    
-    if not parts:
-        return ""
-    
-    return "\n".join(parts)
+    return "\n".join(lines)
 
 
-# Quick response templates for common queries
-QUICK_RESPONSES = {
-    "stress": "Based on your field's stress analysis, ",
-    "water": "Looking at the water content indicators, ",
-    "fertilizer": "Considering your soil nutrient levels, ",
-    "harvest": "For optimal harvest timing, ",
-}
+def format_stage_prompt(template: str, **kwargs) -> str:
+    """Format a stage prompt with provided values."""
+    # Convert context dicts to strings
+    for key, value in kwargs.items():
+        if isinstance(value, dict):
+            kwargs[key] = build_context_prompt(value)
+    
+    return template.format(**kwargs)

reasoning_engine.py

@@ -0,0 +1,374 @@
+"""
+Multi-Stage Reasoning Engine for Agricultural Chatbot
+======================================================
+Implements: Claim → Validate → Contradict → Confirm pipeline
+"""
+
+import json
+import logging
+from typing import Dict, List, Any, Optional, Tuple
+from dataclasses import dataclass
+
+from intent_classifier import IntentClassifier
+from priority_mapper import PriorityContextMapper
+from prompts import (
+    SYSTEM_PROMPT, CLAIM_PROMPT, VALIDATE_PROMPT, 
+    CONTRADICT_PROMPT, CONFIRM_PROMPT, RESPONSE_PROMPT,
+    format_stage_prompt, build_context_prompt
+)
+
+logger = logging.getLogger("ReasoningEngine")
+
+
+@dataclass
+class StageResult:
+    """Result from a single reasoning stage."""
+    stage: str
+    output: Dict[str, Any]
+    context_used: List[str]
+    confidence: float
+
+
+@dataclass
+class ReasoningResult:
+    """Complete reasoning chain result."""
+    claim: StageResult
+    validation: StageResult
+    contradiction: StageResult
+    confirmation: StageResult
+    final_diagnosis: str
+    final_confidence: float
+    causal_chain: str
+    recommendation: str
+    evidence_summary: Dict[str, List[str]]
+
+
+class ReasoningEngine:
+    """
+    Multi-stage reasoning engine for agricultural chatbot.
+    Does NOT ingest all context - uses priority-based selection.
+    """
+    
+    def __init__(self, llm_caller):
+        """
+        Args:
+            llm_caller: Function that takes (prompt: str) -> str
+        """
+        self.llm = llm_caller
+        self.intent_classifier = IntentClassifier()
+        self.priority_mapper = PriorityContextMapper()
+    
+    def process_query(
+        self, 
+        query: str, 
+        context: Optional[Dict[str, Any]] = None
+    ) -> Tuple[str, Dict[str, Any]]:
+        """
+        Process a user query through the full reasoning pipeline.
+        
+        Returns:
+            (response_text, reasoning_trace)
+        """
+        logger.info(f"Processing query: {query[:50]}...")
+        
+        # Stage 1: Classify intent
+        intent = self.intent_classifier.classify(query)
+        logger.info(f"Detected intent: {intent['primary_intent']} ({intent['confidence']})")
+        
+        # Stage 2: Get prioritized context
+        staged_context = self.priority_mapper.build_staged_context(
+            intent=intent["primary_intent"],
+            full_context=context or {}
+        )
+        
+        # Stage 3: Multi-stage reasoning
+        reasoning_result = self._reason(query, intent, staged_context)
+        
+        # Stage 4: Generate response
+        response = self._generate_response(query, reasoning_result)
+        
+        # Build reasoning trace
+        trace = self._build_trace(intent, reasoning_result, staged_context)
+        
+        return response, trace
+    
+    def _reason(
+        self, 
+        query: str, 
+        intent: Dict, 
+        staged_context: Dict
+    ) -> ReasoningResult:
+        """Execute 4-stage reasoning pipeline."""
+        
+        # Stage A: Initial Claim
+        claim = self._stage_claim(query, staged_context["claim_context"])
+        
+        # Stage B: Validate
+        validation = self._stage_validate(
+            claim.output.get("hypothesis", "unknown"),
+            claim.confidence,
+            staged_context["validate_context"]
+        )
+        
+        # Stage C: Contradict
+        contradiction = self._stage_contradict(
+            validation.output.get("hypothesis", claim.output.get("hypothesis", "unknown")),
+            validation.confidence,
+            staged_context["contradict_context"]
+        )
+        
+        # Stage D: Confirm
+        confirmation = self._stage_confirm(
+            hypothesis_1=claim.output.get("hypothesis", "unknown"),
+            conf_1=validation.confidence,
+            hypothesis_2=contradiction.output.get("alternative_hypothesis", "none"),
+            conf_2=contradiction.output.get("alternative_confidence", 0),
+            context=staged_context["confirm_context"]
+        )
+        
+        return ReasoningResult(
+            claim=claim,
+            validation=validation,
+            contradiction=contradiction,
+            confirmation=confirmation,
+            final_diagnosis=confirmation.output.get("final_diagnosis", "Undetermined"),
+            final_confidence=confirmation.confidence,
+            causal_chain=confirmation.output.get("causal_chain", ""),
+            recommendation=confirmation.output.get("recommendation", ""),
+            evidence_summary={
+                "primary": claim.context_used,
+                "supporting": validation.context_used,
+                "alternative": contradiction.context_used,
+                "validation": confirmation.context_used
+            }
+        )
+    
+    def _stage_claim(self, query: str, context: Dict) -> StageResult:
+        """Stage 3A: Make initial claim using Priority 1 context."""
+        prompt = format_stage_prompt(
+            CLAIM_PROMPT,
+            query=query,
+            priority_1_context=context
+        )
+        
+        full_prompt = f"{SYSTEM_PROMPT}\n\n{prompt}"
+        response = self.llm(full_prompt)
+        
+        try:
+            output = self._parse_json(response)
+        except:
+            output = {
+                "initial_claim": response,
+                "hypothesis": "general_issue",
+                "confidence": 0.5
+            }
+        
+        return StageResult(
+            stage="claim",
+            output=output,
+            context_used=list(context.keys()),
+            confidence=output.get("confidence", 0.5)
+        )
+    
+    def _stage_validate(
+        self, 
+        hypothesis: str, 
+        confidence: float, 
+        context: Dict
+    ) -> StageResult:
+        """Stage 3B: Validate hypothesis using Priority 2 context."""
+        prompt = format_stage_prompt(
+            VALIDATE_PROMPT,
+            previous_hypothesis=hypothesis,
+            previous_confidence=confidence,
+            priority_2_context=context
+        )
+        
+        full_prompt = f"{SYSTEM_PROMPT}\n\n{prompt}"
+        response = self.llm(full_prompt)
+        
+        try:
+            output = self._parse_json(response)
+        except:
+            output = {
+                "validation_result": "neutral",
+                "confidence_updated": confidence
+            }
+        
+        # Carry forward hypothesis
+        output["hypothesis"] = hypothesis
+        
+        return StageResult(
+            stage="validate",
+            output=output,
+            context_used=list(context.keys()),
+            confidence=output.get("confidence_updated", confidence)
+        )
+    
+    def _stage_contradict(
+        self, 
+        hypothesis: str, 
+        confidence: float, 
+        context: Dict
+    ) -> StageResult:
+        """Stage 3C: Seek contradictions using Priority 3 context."""
+        prompt = format_stage_prompt(
+            CONTRADICT_PROMPT,
+            hypothesis=hypothesis,
+            confidence=confidence,
+            priority_3_context=context
+        )
+        
+        full_prompt = f"{SYSTEM_PROMPT}\n\n{prompt}"
+        response = self.llm(full_prompt)
+        
+        try:
+            output = self._parse_json(response)
+        except:
+            output = {
+                "contradiction_found": False,
+                "alternative_hypothesis": "none",
+                "alternative_confidence": 0
+            }
+        
+        return StageResult(
+            stage="contradict",
+            output=output,
+            context_used=list(context.keys()),
+            confidence=output.get("alternative_confidence", 0)
+        )
+    
+    def _stage_confirm(
+        self,
+        hypothesis_1: str,
+        conf_1: float,
+        hypothesis_2: str,
+        conf_2: float,
+        context: Dict
+    ) -> StageResult:
+        """Stage 3D: Final confirmation using Priority 4 context."""
+        prompt = format_stage_prompt(
+            CONFIRM_PROMPT,
+            hypothesis_1=hypothesis_1,
+            conf_1=conf_1,
+            hypothesis_2=hypothesis_2,
+            conf_2=conf_2,
+            priority_4_context=context
+        )
+        
+        full_prompt = f"{SYSTEM_PROMPT}\n\n{prompt}"
+        response = self.llm(full_prompt)
+        
+        try:
+            output = self._parse_json(response)
+        except:
+            # Generate simple output if parsing fails
+            output = {
+                "final_diagnosis": f"Likely {hypothesis_1}",
+                "confidence": conf_1,
+                "recommendation": "Further investigation recommended"
+            }
+        
+        return StageResult(
+            stage="confirm",
+            output=output,
+            context_used=list(context.keys()),
+            confidence=output.get("confidence", conf_1)
+        )
+    
+    def _generate_response(self, query: str, result: ReasoningResult) -> str:
+        """Generate final user-facing response."""
+        prompt = format_stage_prompt(
+            RESPONSE_PROMPT,
+            query=query,
+            diagnosis=json.dumps({
+                "diagnosis": result.final_diagnosis,
+                "confidence": result.final_confidence,
+                "causal_chain": result.causal_chain,
+                "recommendation": result.recommendation
+            }, indent=2),
+            evidence=json.dumps(result.evidence_summary, indent=2)
+        )
+        
+        full_prompt = f"{SYSTEM_PROMPT}\n\n{prompt}"
+        response = self.llm(full_prompt)
+        
+        return response
+    
+    def _build_trace(
+        self, 
+        intent: Dict, 
+        result: ReasoningResult,
+        staged_context: Dict
+    ) -> Dict[str, Any]:
+        """Build reasoning trace for debugging/transparency."""
+        return {
+            "intent_detected": intent["primary_intent"],
+            "intent_confidence": intent["confidence"],
+            "sub_intents": intent["sub_intents"],
+            "stages": {
+                "claim": {
+                    "hypothesis": result.claim.output.get("hypothesis"),
+                    "confidence": result.claim.confidence,
+                    "context_used": result.claim.context_used
+                },
+                "validation": {
+                    "result": result.validation.output.get("validation_result"),
+                    "confidence": result.validation.confidence,
+                    "context_used": result.validation.context_used
+                },
+                "contradiction": {
+                    "found": result.contradiction.output.get("contradiction_found"),
+                    "alternative": result.contradiction.output.get("alternative_hypothesis"),
+                    "confidence": result.contradiction.confidence,
+                    "context_used": result.contradiction.context_used
+                },
+                "confirmation": {
+                    "final": result.final_diagnosis,
+                    "confidence": result.final_confidence,
+                    "context_used": result.confirmation.context_used
+                }
+            },
+            "causal_chain": result.causal_chain,
+            "evidence_summary": result.evidence_summary
+        }
+    
+    def _parse_json(self, text: str) -> Dict:
+        """Extract and parse JSON from LLM response."""
+        # Try to find JSON in response
+        text = text.strip()
+        
+        # Look for JSON block
+        if "```json" in text:
+            start = text.find("```json") + 7
+            end = text.find("```", start)
+            text = text[start:end].strip()
+        elif "```" in text:
+            start = text.find("```") + 3
+            end = text.find("```", start)
+            text = text[start:end].strip()
+        
+        # Find JSON object
+        start = text.find("{")
+        end = text.rfind("}") + 1
+        if start >= 0 and end > start:
+            text = text[start:end]
+        
+        return json.loads(text)
+
+
+# Simple interface for single-stage reasoning (fallback)
+def simple_reason(query: str, context: Dict, llm_caller) -> str:
+    """Simplified single-stage reasoning for when full pipeline isn't needed."""
+    context_str = build_context_prompt(context) if context else "No context available."
+    
+    prompt = f"""{SYSTEM_PROMPT}
+
+User Query: {query}
+
+Available Context:
+{context_str}
+
+Provide a helpful, actionable response."""
+    
+    return llm_caller(prompt)