Restore original simple chatbot from initial commit

app.py

@@ -1,10 +1,10 @@
 """
-AGROW Agricultural Chatbot Service (Simplified)
-================================================
-AI-powered agricultural advisor with:
-- Single LLM call (no multi-stage reasoning)
-- Multi-API key fallback
+AGROW Agricultural Chatbot Service
+===================================
+AI-powered agricultural advisor using Gemini LLM with:
+- Context from pipeline outputs (stress, NDVI, forecasts)
 - Supabase conversation storage
+- Session management
 """
 
 import os
@@ -14,15 +14,14 @@ import uuid
 from datetime import datetime
 from typing import Optional, List, Dict, Any
 import traceback
-import requests
 
 from fastapi import FastAPI, HTTPException
 from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import StreamingResponse
 from pydantic import BaseModel
-import asyncio
+import google.generativeai as genai
 
 from supabase_client import SupabaseClient
+from prompts import SYSTEM_PROMPT, build_context_prompt
 
 # ============================================================================
 # LOGGING
@@ -35,77 +34,29 @@ logging.basicConfig(
 logger = logging.getLogger("ChatbotService")
 
 # ============================================================================
-# GEMINI SETUP - Multi-API Key Fallback System
+# GEMINI SETUP
 # ============================================================================
-def load_gemini_api_keys() -> List[str]:
-    """Load all available Gemini API keys from environment."""
-    keys = []
-    primary = os.environ.get("GEMINI_API_KEY")
-    if primary:
-        keys.append(primary)
-    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
-logger.info(f"Loaded {len(GEMINI_API_KEYS)} Gemini API key(s)")
-
-# Find working model
-def get_available_model(api_key: str):
-    """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:
-        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
-
-GEMINI_URL, GEMINI_MODEL = None, None
-if GEMINI_API_KEYS:
-    GEMINI_URL, GEMINI_MODEL = get_available_model(GEMINI_API_KEYS[0])
-    logger.info(f"Using Gemini model: {GEMINI_MODEL}")
+GEMINI_API_KEY = os.environ.get("GEMINI_API_KEY")
+if GEMINI_API_KEY:
+    genai.configure(api_key=GEMINI_API_KEY)
+    model = genai.GenerativeModel('gemini-1.5-flash')
+    logger.info("Gemini API configured successfully")
+else:
+    model = None
+    logger.warning("GEMINI_API_KEY not set - chatbot will return mock responses")
 
 # Supabase client
 supabase = SupabaseClient()
 
 # ============================================================================
-# SIMPLE SYSTEM PROMPT
+# FASTAPI
 # ============================================================================
-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
-
-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."""
+app = FastAPI(
+    title="AGROW Chatbot Service",
+    description="AI agricultural advisor with conversation storage",
+    version="1.0.0"
+)
 
-# ============================================================================
-# FASTAPI SETUP
-# ============================================================================
-app = FastAPI(title="AGROW Chatbot Service", version="2.0")
 app.add_middleware(
     CORSMiddleware,
     allow_origins=["*"],
@@ -114,10 +65,6 @@ 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
 # ============================================================================
@@ -125,16 +72,13 @@ class ChatRequest(BaseModel):
     session_id: str
     message: str
     user_id: Optional[str] = None
-    field_id: Optional[str] = None
-
-class ResponseContent(BaseModel):
-    message: str
-    confidence: float = 0.8
+    field_context: Optional[Dict[str, Any]] = None  # Pipeline data
 
 class ChatResponse(BaseModel):
-    response: ResponseContent
+    response: str
     session_id: str
     message_id: str
+    context_used: List[str]
     timestamp: str
 
 class SessionRequest(BaseModel):
@@ -146,85 +90,69 @@ 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]
+
+class SessionListItem(BaseModel):
+    id: str
+    title: str
+    created_at: str
+    updated_at: str
+    message_count: int
+
 # ============================================================================
-# LLM CALL WITH FALLBACK
+# HELPER FUNCTIONS
 # ============================================================================
-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]
-
-def call_gemini_api(prompt: str) -> str:
-    """Call Gemini API with fallback across multiple API keys."""
-    global current_key_index
+def generate_response(user_message: str, history: List[Dict], context: Optional[Dict] = None) -> tuple[str, List[str]]:
+    """Generate AI response using Gemini."""
+    context_used = []
     
-    if not GEMINI_API_KEYS:
-        return "Please configure GEMINI_API_KEY for real responses."
+    # Build conversation history for context
+    conversation = []
+    for msg in history[-10:]:  # Last 10 messages for context
+        role = "user" if msg.get("role") == "user" else "model"
+        conversation.append({"role": role, "parts": [msg.get("content", "")]})
     
-    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
+    # Build context prompt if pipeline data available
+    context_prompt = ""
+    if context:
+        context_prompt = build_context_prompt(context)
+        context_used = list(context.keys())
     
-    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."""
+    # 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 = ""
-    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"
+    if model is None:
+        # Mock response if no API key
+        return f"I received your question: '{user_message}'. Please configure GEMINI_API_KEY for real responses.", []
     
-    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)
+    try:
+        # Create chat with system instruction
+        chat = model.start_chat(history=conversation)
+        
+        # Generate response
+        response = chat.send_message(
+            f"[System: {full_system}]\n\nUser: {user_message}",
+            generation_config=genai.types.GenerationConfig(
+                temperature=0.7,
+                max_output_tokens=1024,
+            )
+        )
+        
+        return response.text, context_used
+        
+    except Exception as e:
+        logger.error(f"Gemini error: {e}")
+        return f"I apologize, but I encountered an error. Please try again. Error: {str(e)}", []
 
 # ============================================================================
 # API ENDPOINTS
@@ -233,27 +161,35 @@ Provide a helpful, actionable response:"""
 async def root():
     return {
         "service": "AGROW Chatbot Service",
-        "version": "2.0-simple",
-        "status": "running"
+        "version": "1.0.0",
+        "endpoints": {
+            "/chat": "POST - Send message, get AI response",
+            "/session/new": "POST - Create new chat session",
+            "/session/{id}/history": "GET - Get conversation history",
+            "/sessions/{user_id}": "GET - List user's sessions"
+        }
     }
 
 @app.get("/health")
 async def health():
     return {
         "status": "healthy",
-        "gemini_configured": GEMINI_URL is not None,
-        "api_keys_loaded": len(GEMINI_API_KEYS)
+        "gemini_configured": model is not None,
+        "supabase_configured": supabase.is_configured()
     }
 
+
 @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"],
@@ -263,14 +199,15 @@ 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 (single LLM call)."""
-    logger.info(f"Chat request - Session: {request.session_id}")
+    """Send a message and get AI response."""
+    logger.info(f"Chat request - Session: {request.session_id}, Message: {request.message[:50]}...")
     
     try:
-        # Get conversation history
-        history = supabase.get_messages(request.session_id) or []
+        # Load conversation history
+        history = supabase.get_messages(request.session_id)
         
         # Save user message
         user_msg_id = supabase.add_message(
@@ -279,24 +216,31 @@ async def chat(request: ChatRequest):
             content=request.message
         )
         
-        # Generate response (SINGLE LLM CALL)
-        logger.info("Generating response (single LLM call)")
-        response_text = generate_simple_response(request.message, history)
+        # Generate AI response
+        response_text, context_used = generate_response(
+            request.message, 
+            history,
+            request.field_context
+        )
         
         # Save assistant response
         assistant_msg_id = supabase.add_message(
             session_id=request.session_id,
             role="assistant",
-            content=response_text
+            content=response_text,
+            context_used=context_used
         )
         
+        # Update session timestamp
         supabase.update_session_timestamp(request.session_id)
+        
         logger.info(f"Response generated - {len(response_text)} chars")
         
         return ChatResponse(
-            response=ResponseContent(message=response_text),
+            response=response_text,
             session_id=request.session_id,
             message_id=assistant_msg_id,
+            context_used=context_used,
             timestamp=datetime.now().isoformat()
         )
         
@@ -305,84 +249,64 @@ async def chat(request: ChatRequest):
         logger.error(traceback.format_exc())
         raise HTTPException(500, str(e))
 
-@app.post("/chat/stream")
-async def chat_stream(request: ChatRequest):
-    """Streaming chat endpoint (also uses single LLM call, then streams)."""
-    logger.info(f"Stream chat request - Session: {request.session_id}")
-    
-    try:
-        history = supabase.get_messages(request.session_id) or []
-        
-        supabase.add_message(
-            session_id=request.session_id,
-            role="user",
-            content=request.message
-        )
-        
-        # Generate full response first
-        response_text = generate_simple_response(request.message, history)
-        
-        assistant_msg_id = supabase.add_message(
-            session_id=request.session_id,
-            role="assistant",
-            content=response_text
-        )
-        
-        supabase.update_session_timestamp(request.session_id)
-        
-        # Stream response in chunks
-        async def generate_stream():
-            chunk_size = 15
-            delay = 0.03
-            
-            # Send metadata
-            yield f"data: {json.dumps({'type': 'metadata', 'session_id': request.session_id, 'message_id': assistant_msg_id})}\n\n"
-            
-            # Stream text chunks
-            for i in range(0, len(response_text), chunk_size):
-                chunk = response_text[i:i+chunk_size]
-                yield f"data: {json.dumps({'type': 'chunk', 'text': chunk})}\n\n"
-                await asyncio.sleep(delay)
-            
-            # Done signal
-            yield f"data: {json.dumps({'type': 'done', 'full_text': response_text})}\n\n"
-        
-        return StreamingResponse(generate_stream(), media_type="text/event-stream")
-        
-    except Exception as e:
-        logger.error(f"Stream chat error: {e}")
-        raise HTTPException(500, str(e))
 
-@app.get("/session/{session_id}/history")
+@app.get("/session/{session_id}/history", response_model=HistoryResponse)
 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 {"session_id": session_id, "messages": messages}
+        
+        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
+            ]
+        )
     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."""
+    """Delete a chat session and its messages."""
     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))
 
+
 if __name__ == "__main__":
     import uvicorn
-    logger.info("Starting AGROW Chatbot Service v2.0 (Simple)")
+    logger.info("Starting AGROW Chatbot Service")
     uvicorn.run(app, host="0.0.0.0", port=7860)