Add comprehensive context: all indices, SAR, weather, persona-based responses

app.py

@@ -1,10 +1,13 @@
 """
 AGROW Agricultural Chatbot Service
 ===================================
-AI-powered agricultural advisor using Gemini LLM with:
-- Context from pipeline outputs (stress, NDVI, forecasts)
-- Supabase conversation storage
-- Session management
+AI-powered agricultural advisor with comprehensive context from:
+- SAR bands (VV, VH) and analysis
+- Sentinel-2 vegetation indices (all 13)
+- Weather data (current + forecast)
+- Clustering and stress patterns
+- Farmer profile from questionnaire
+- Field data from coordinates_quad
 """
 
 import os
@@ -23,7 +26,8 @@ import asyncio
 import google.generativeai as genai
 
 from supabase_client import SupabaseClient
-from prompts import SYSTEM_PROMPT, build_context_prompt
+from context_aggregator import ContextAggregator
+from prompts import PERSONA_DEFINITIONS, EXPERIENCE_MAP, TECH_COMFORT_MAP, INNOVATION_MAP, FARMING_GOAL_MAP
 
 # ============================================================================
 # LOGGING
@@ -35,6 +39,10 @@ logging.basicConfig(
 )
 logger = logging.getLogger("ChatbotService")
 
+print("=" * 50)
+print(f"===== Application Startup at {datetime.now().strftime('%Y-%m-%d %H:%M:%S')} =====")
+print("=" * 50)
+
 # ============================================================================
 # GEMINI SETUP
 # ============================================================================
@@ -47,16 +55,17 @@ else:
     model = None
     logger.warning("GEMINI_API_KEY not set - chatbot will return mock responses")
 
-# Supabase client
+# Supabase and Context Aggregator
 supabase = SupabaseClient()
+context_aggregator = ContextAggregator(timeout=60)
 
 # ============================================================================
 # FASTAPI
 # ============================================================================
 app = FastAPI(
     title="AGROW Chatbot Service",
-    description="AI agricultural advisor with conversation storage",
-    version="1.0.0"
+    description="AI agricultural advisor with comprehensive satellite context",
+    version="2.0.0"
 )
 
 app.add_middleware(
@@ -74,7 +83,7 @@ class ChatRequest(BaseModel):
     session_id: str
     message: str
     user_id: Optional[str] = None
-    field_context: Optional[Dict[str, Any]] = None  # Pipeline data
+    field_id: Optional[str] = None  # Specific field to analyze
 
 class ChatResponse(BaseModel):
     response: str
@@ -102,51 +111,351 @@ 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
 
 # ============================================================================
-# HELPER FUNCTIONS
+# PERSONA DETECTION
+# ============================================================================
+def detect_persona(questionnaire: Dict) -> str:
+    """Detect user persona from questionnaire answers."""
+    if not questionnaire:
+        return "experienced_farmer_traditional"
+    
+    experience = questionnaire.get("experience", "2 - 5 years")
+    tech = questionnaire.get("tech_comfort", "I can use basic features")
+    innovation = questionnaire.get("innovation", "I try new methods occasionally")
+    goal = questionnaire.get("farming_goal", "Earn Income / Livelihood")
+    role = questionnaire.get("role", "Farmer")
+    
+    # Map to persona
+    years = EXPERIENCE_MAP.get(experience, 3)
+    tech_level = TECH_COMFORT_MAP.get(tech, "moderate")
+    innovation_level = INNOVATION_MAP.get(innovation, "moderate")
+    goal_type = FARMING_GOAL_MAP.get(goal, "income")
+    
+    # Role-based override
+    if role == "Agricultural Officer":
+        return "agricultural_officer"
+    elif role in ["Agronomist", "Researcher"]:
+        return "agronomist_researcher"
+    
+    # Experience + innovation matrix
+    if years < 3:
+        return "new_farmer_tech_savvy" if tech_level == "advanced" else "new_farmer_basic_tech"
+    elif goal_type == "commercial":
+        return "commercial_farmer"
+    elif innovation_level == "innovative":
+        return "experienced_farmer_innovative"
+    else:
+        return "experienced_farmer_traditional"
+
+
+# ============================================================================
+# FETCH COMPREHENSIVE CONTEXT
 # ============================================================================
-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 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", "")]})
-    
-    # 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}"
+def fetch_field_data(user_id: str, field_id: Optional[str] = None) -> Optional[Dict]:
+    """Fetch field data from Supabase coordinates_quad."""
+    try:
+        if field_id:
+            query = supabase.client.table("coordinates_quad").select("*").eq("id", field_id).limit(1).execute()
+        else:
+            query = supabase.client.table("coordinates_quad").select("*").eq("user_id", user_id).limit(1).execute()
+        
+        if query.data and len(query.data) > 0:
+            field = query.data[0]
+            # Calculate center point
+            lats = [field.get(f"lat{i}", 0) for i in range(1, 5)]
+            lons = [field.get(f"lon{i}", 0) for i in range(1, 5)]
+            center_lat = sum(lats) / 4
+            center_lon = sum(lons) / 4
+            
+            return {
+                "id": field.get("id"),
+                "name": field.get("name", "My Field"),
+                "crop_type": field.get("crop_type", "Wheat"),
+                "area_acres": field.get("area_acres", 1.0),
+                "coordinates": {
+                    "center_lat": center_lat,
+                    "center_lon": center_lon,
+                    "bbox": [min(lons), min(lats), max(lons), max(lats)]
+                }
+            }
+    except Exception as e:
+        logger.error(f"Error fetching field data: {e}")
+    return None
+
+
+def fetch_user_profile(user_id: str) -> Dict:
+    """Fetch user profile and questionnaire from Supabase."""
+    try:
+        query = supabase.client.table("user_profiles").select(
+            "full_name, address, questionnaire_data"
+        ).eq("user_id", user_id).limit(1).execute()
+        
+        if query.data and len(query.data) > 0:
+            profile = query.data[0]
+            return {
+                "name": profile.get("full_name", ""),
+                "location": profile.get("address", ""),
+                "questionnaire": profile.get("questionnaire_data", {})
+            }
+    except Exception as e:
+        logger.error(f"Error fetching user profile: {e}")
+    return {"name": "", "location": "", "questionnaire": {}}
+
+
+def build_comprehensive_context(user_id: str, field_id: Optional[str] = None) -> Dict:
+    """Build comprehensive context from all data sources."""
+    context = {
+        "fetch_timestamp": datetime.now().isoformat(),
+        "data_sources": []
+    }
+    
+    # 1. Fetch field data
+    field_data = fetch_field_data(user_id, field_id)
+    if field_data:
+        context["field_info"] = field_data
+        context["data_sources"].append("coordinates_quad")
+        logger.info(f"Field data fetched: {field_data.get('name')}")
+    else:
+        return context  # Can't proceed without field
+    
+    # 2. Fetch user profile and questionnaire
+    user_profile = fetch_user_profile(user_id)
+    questionnaire = user_profile.get("questionnaire", {})
+    persona = detect_persona(questionnaire)
+    
+    context["farmer_profile"] = {
+        "name": user_profile.get("name", ""),
+        "location": user_profile.get("location", ""),
+        "persona": persona,
+        "questionnaire": questionnaire
+    }
+    context["data_sources"].append("user_profiles")
+    logger.info(f"Farmer persona detected: {persona}")
+    
+    # 3. Fetch satellite context using ContextAggregator
+    coordinates = field_data.get("coordinates", {})
+    crop_type = field_data.get("crop_type", "Wheat")
+    area_acres = field_data.get("area_acres", 1.0)
+    
+    satellite_context = context_aggregator.fetch_full_context(
+        coordinates=coordinates,
+        crop_type=crop_type,
+        area_acres=area_acres,
+        farmer_context={"profile": user_profile, "questionnaire": questionnaire}
+    )
+    
+    # Merge satellite data
+    if satellite_context.get("sar_bands"):
+        context["sar_bands"] = satellite_context["sar_bands"]
+        context["data_sources"].append("sar_api")
+    
+    if satellite_context.get("vegetation_indices"):
+        context["vegetation_indices"] = satellite_context["vegetation_indices"]
+        context["data_sources"].append("sentinel2_api")
+    
+    if satellite_context.get("soil_indicators"):
+        context["soil_indicators"] = satellite_context["soil_indicators"]
+    
+    if satellite_context.get("clustering"):
+        context["clustering"] = satellite_context["clustering"]
+    
+    if satellite_context.get("temporal_trends"):
+        context["temporal_trends"] = satellite_context["temporal_trends"]
+    
+    if satellite_context.get("historical_trends"):
+        context["historical_trends"] = satellite_context["historical_trends"]
+    
+    if satellite_context.get("weather"):
+        context["weather"] = satellite_context["weather"]
+        context["data_sources"].append("weather_api")
+    
+    if satellite_context.get("stressed_patches"):
+        context["stressed_patches"] = satellite_context["stressed_patches"]
+    
+    if satellite_context.get("zone_analysis"):
+        context["zone_analysis"] = satellite_context["zone_analysis"]
+    
+    if satellite_context.get("anomalies"):
+        context["anomalies"] = satellite_context["anomalies"]
+    
+    logger.info(f"Context built from sources: {context['data_sources']}")
+    return context
+
+
+# ============================================================================
+# BUILD LLM PROMPT WITH CONTEXT
+# ============================================================================
+def build_llm_prompt(query: str, context: Dict, history: List[Dict] = None) -> str:
+    """Build comprehensive prompt for LLM with all context."""
+    
+    # Get persona for response style
+    persona_key = context.get("farmer_profile", {}).get("persona", "experienced_farmer_traditional")
+    persona = PERSONA_DEFINITIONS.get(persona_key, PERSONA_DEFINITIONS["experienced_farmer_traditional"])
+    
+    # Build context string
+    context_parts = []
+    
+    # Field info
+    if context.get("field_info"):
+        field = context["field_info"]
+        context_parts.append(f"""## Field Information
+- Name: {field.get('name', 'Unknown')}
+- Crop: {field.get('crop_type', 'Unknown')}
+- Area: {field.get('area_acres', 0):.2f} acres
+- Location: {field.get('coordinates', {}).get('center_lat', 0):.4f}°N, {field.get('coordinates', {}).get('center_lon', 0):.4f}°E""")
+    
+    # Vegetation indices (all 13)
+    if context.get("vegetation_indices"):
+        vi = context["vegetation_indices"]
+        vi_lines = ["## Vegetation Indices (Sentinel-2)"]
+        for name, data in vi.items():
+            if isinstance(data, dict):
+                mean = data.get("mean", data.get("value", "N/A"))
+                change = data.get("temporal_change", data.get("change", ""))
+                change_str = f" (Δ{change:+.3f})" if isinstance(change, (int, float)) else ""
+                vi_lines.append(f"- {name}: {mean:.4f}{change_str}" if isinstance(mean, float) else f"- {name}: {mean}")
+        context_parts.append("\n".join(vi_lines))
+    
+    # SAR bands
+    if context.get("sar_bands"):
+        sar = context["sar_bands"]
+        context_parts.append(f"""## SAR Backscatter (Sentinel-1)
+- VV: {sar.get('VV', {}).get('mean', 'N/A')} dB
+- VH: {sar.get('VH', {}).get('mean', 'N/A')} dB
+- VV/VH Ratio: {sar.get('VV_VH_ratio', 'N/A')}""")
+    
+    # Soil indicators
+    if context.get("soil_indicators"):
+        soil = context["soil_indicators"]
+        soil_lines = ["## Soil Indicators"]
+        for name, data in soil.items():
+            level = data.get("level", "unknown") if isinstance(data, dict) else data
+            value = data.get("value", "") if isinstance(data, dict) else ""
+            val_str = f" ({value:.2f})" if isinstance(value, float) else ""
+            soil_lines.append(f"- {name.replace('_', ' ').title()}: {level}{val_str}")
+        context_parts.append("\n".join(soil_lines))
+    
+    # Clustering
+    if context.get("clustering"):
+        cl = context["clustering"]
+        context_parts.append(f"""## Spatial Clustering
+- Clusters: {cl.get('num_clusters', 'N/A')}
+- Distribution: {json.dumps(cl.get('cluster_distribution', {}))}
+- Pattern: {cl.get('spatial_pattern', 'N/A')}""")
+    
+    # Temporal trends
+    if context.get("temporal_trends"):
+        tt = context["temporal_trends"]
+        context_parts.append(f"""## Temporal Trends
+- NDVI Trend: {tt.get('ndvi_trend', 'N/A')}
+- 7-day Change: {tt.get('7_day_change', 'N/A')}
+- 30-day Change: {tt.get('30_day_change', 'N/A')}
+- Anomaly: {tt.get('anomaly_detected', 'N/A')}""")
+    
+    # Weather
+    if context.get("weather"):
+        w = context["weather"]
+        current = w.get("current", {})
+        forecast = w.get("forecast_7_day", w.get("forecast", {}))
+        context_parts.append(f"""## Weather Data
+- Current: {current.get('temp', 'N/A')}°C, Humidity: {current.get('humidity', 'N/A')}%
+- 7-day Avg Temp: {w.get('7_day_avg', {}).get('temp', 'N/A')}°C
+- Precipitation: {w.get('7_day_avg', {}).get('total_precipitation', 'N/A')} mm
+- Forecast Rain Probability: {forecast.get('rain_probability', 'N/A')}%""")
+    
+    # Stressed patches
+    if context.get("stressed_patches") and len(context["stressed_patches"]) > 0:
+        patches = context["stressed_patches"][:3]  # Top 3
+        patch_lines = ["## Stress Zones Detected"]
+        for p in patches:
+            patch_lines.append(f"- {p.get('location', 'Unknown')}: Score {p.get('stress_score', 0):.2f}, Area: {p.get('area_percent', 0):.1f}%")
+        context_parts.append("\n".join(patch_lines))
+    
+    # Zone analysis
+    if context.get("zone_analysis"):
+        za = context["zone_analysis"]
+        if za.get("most_critical"):
+            mc = za["most_critical"]
+            context_parts.append(f"""## Priority Zone
+- Location: {mc.get('location', 'Unknown')}
+- Issue: {mc.get('issue', 'Unknown')}
+- Urgency: {mc.get('urgency', 'Medium')}""")
+    
+    # Farmer profile
+    if context.get("farmer_profile"):
+        fp = context["farmer_profile"]
+        q = fp.get("questionnaire", {})
+        context_parts.append(f"""## Farmer Profile
+- Experience: {q.get('experience', 'Unknown')}
+- Farming Goal: {q.get('farming_goal', 'Unknown')}
+- Tech Comfort: {q.get('tech_comfort', 'Unknown')}
+- Persona: {persona.get('description', '')}""")
+    
+    # Build conversation history
+    history_text = ""
+    if history and len(history) > 0:
+        recent = history[-4:]  # Last 2 exchanges
+        history_text = "\n## Recent Conversation\n"
+        for msg in recent:
+            role = "User" if msg.get("role") == "user" else "Assistant"
+            history_text += f"{role}: {msg.get('content', '')[:150]}...\n"
+    
+    # Combine into full prompt
+    context_str = "\n\n".join(context_parts)
+    
+    prompt = f"""You are AGROW AI, an expert agricultural advisor for Indian farmers.
+
+# RESPONSE STYLE FOR THIS USER
+{persona.get('description', '')}
+- Style: {persona.get('style', '')}
+- Format: {persona.get('format', '')}
+- Focus: {persona.get('focus', '')}
+- Tone: {persona.get('tone', '')}
+- Recommendations: {persona.get('recommendations', '')}
+
+# FIELD ANALYSIS DATA
+{context_str}
+{history_text}
+
+# USER QUERY
+{query}
+
+# INSTRUCTIONS
+1. Analyze the satellite data thoroughly
+2. Provide actionable recommendations matching the user's persona
+3. Reference specific data values when relevant
+4. Be concise but comprehensive
+5. Prioritize urgent issues first
+
+Provide your response:"""
+
+    return prompt
+
+
+# ============================================================================
+# GENERATE RESPONSE
+# ============================================================================
+def generate_response(user_message: str, history: List[Dict], context: Dict) -> tuple[str, List[str]]:
+    """Generate AI response using comprehensive context."""
+    context_used = context.get("data_sources", [])
     
     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.", []
+        return f"Please configure GEMINI_API_KEY for real responses.", []
     
     try:
-        # Create chat with system instruction
-        chat = model.start_chat(history=conversation)
+        # Build comprehensive prompt
+        prompt = build_llm_prompt(user_message, context, history)
+        
+        # Log context summary
+        logger.info(f"Context: {len(context_used)} sources, Prompt: {len(prompt)} chars")
         
         # Generate response
-        response = chat.send_message(
-            f"[System: {full_system}]\n\nUser: {user_message}",
+        response = model.generate_content(
+            prompt,
             generation_config=genai.types.GenerationConfig(
                 temperature=0.7,
-                max_output_tokens=1024,
+                max_output_tokens=2048,
             )
         )
         
@@ -154,7 +463,8 @@ def generate_response(user_message: str, history: List[Dict], context: Optional[
         
     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)}", []
+        return f"I apologize, but I encountered an error: {str(e)}", []
+
 
 # ============================================================================
 # API ENDPOINTS
@@ -163,13 +473,8 @@ def generate_response(user_message: str, history: List[Dict], context: Optional[
 async def root():
     return {
         "service": "AGROW Chatbot Service",
-        "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"
-        }
+        "version": "2.0.0",
+        "features": ["comprehensive_context", "persona_based_responses", "satellite_analysis"]
     }
 
 @app.get("/health")
@@ -185,13 +490,11 @@ async def health():
 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"],
@@ -204,8 +507,8 @@ async def create_session(request: SessionRequest):
 
 @app.post("/chat", response_model=ChatResponse)
 async def chat(request: ChatRequest):
-    """Send a message and get AI response."""
-    logger.info(f"Chat request - Session: {request.session_id}, Message: {request.message[:50]}...")
+    """Send a message and get AI response with full context."""
+    logger.info(f"Chat request - Session: {request.session_id}")
     
     try:
         # Load conversation history
@@ -218,12 +521,14 @@ async def chat(request: ChatRequest):
             content=request.message
         )
         
+        # Build comprehensive context
+        context = {}
+        if request.user_id:
+            context = build_comprehensive_context(request.user_id, request.field_id)
+            logger.info(f"Context built: {context.get('data_sources', [])}")
+        
         # Generate AI response
-        response_text, context_used = generate_response(
-            request.message, 
-            history,
-            request.field_context
-        )
+        response_text, context_used = generate_response(request.message, history, context)
         
         # Save assistant response
         assistant_msg_id = supabase.add_message(
@@ -233,9 +538,7 @@ async def chat(request: ChatRequest):
             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(
@@ -252,14 +555,69 @@ async def chat(request: ChatRequest):
         raise HTTPException(500, str(e))
 
 
+@app.post("/chat/stream")
+async def chat_stream(request: ChatRequest):
+    """Stream chat response with full context."""
+    logger.info(f"Stream chat - Session: {request.session_id}")
+    
+    try:
+        history = supabase.get_messages(request.session_id)
+        
+        supabase.add_message(
+            session_id=request.session_id,
+            role="user",
+            content=request.message
+        )
+        
+        # Build comprehensive context
+        context = {}
+        if request.user_id:
+            context = build_comprehensive_context(request.user_id, request.field_id)
+            logger.info(f"Context built: {context.get('data_sources', [])}")
+        
+        # Generate response
+        response_text, context_used = generate_response(request.message, history, context)
+        
+        assistant_msg_id = supabase.add_message(
+            session_id=request.session_id,
+            role="assistant",
+            content=response_text,
+            context_used=context_used
+        )
+        
+        supabase.update_session_timestamp(request.session_id)
+        
+        async def stream_response():
+            # Send metadata
+            yield f"data: {json.dumps({'type': 'metadata', 'session_id': request.session_id, 'message_id': assistant_msg_id, 'context_sources': context_used})}\n\n"
+            
+            # Stream text in chunks
+            for i in range(0, len(response_text), 15):
+                yield f"data: {json.dumps({'type': 'chunk', 'text': response_text[i:i+15]})}\n\n"
+                await asyncio.sleep(0.03)
+            
+            # Done signal
+            yield f"data: {json.dumps({'type': 'done', 'full_text': response_text})}\n\n"
+        
+        return StreamingResponse(stream_response(), media_type="text/event-stream")
+        
+    except Exception as e:
+        logger.error(f"Stream error: {e}")
+        raise HTTPException(500, str(e))
+
+
+@app.get("/context/{user_id}")
+async def get_context(user_id: str, field_id: Optional[str] = None):
+    """Get the comprehensive context JSON for debugging."""
+    context = build_comprehensive_context(user_id, field_id)
+    return context
+
+
 @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 HistoryResponse(
             session_id=session_id,
             messages=[
@@ -273,7 +631,6 @@ async def get_history(session_id: str):
             ]
         )
     except Exception as e:
-        logger.error(f"History error: {e}")
         raise HTTPException(500, str(e))
 
 
@@ -281,75 +638,25 @@ async def get_history(session_id: str):
 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))
-
-
-@app.post("/chat/stream")
-async def chat_stream(request: ChatRequest):
-    """Stream chat response for Flutter app."""
-    logger.info(f"Stream chat - Session: {request.session_id}")
-    
-    try:
-        history = supabase.get_messages(request.session_id)
-        
-        supabase.add_message(
-            session_id=request.session_id,
-            role="user",
-            content=request.message
-        )
-        
-        response_text, context_used = generate_response(
-            request.message, history, request.field_context
-        )
-        
-        assistant_msg_id = supabase.add_message(
-            session_id=request.session_id,
-            role="assistant",
-            content=response_text,
-            context_used=context_used
-        )
-        
-        supabase.update_session_timestamp(request.session_id)
-        
-        async def stream_response():
-            yield f"data: {json.dumps({'type': 'metadata', 'session_id': request.session_id, 'message_id': assistant_msg_id})}\n\n"
-            for i in range(0, len(response_text), 15):
-                yield f"data: {json.dumps({'type': 'chunk', 'text': response_text[i:i+15]})}\n\n"
-                await asyncio.sleep(0.03)
-            yield f"data: {json.dumps({'type': 'done', 'full_text': response_text})}\n\n"
-        
-        return StreamingResponse(stream_response(), media_type="text/event-stream")
-        
-    except Exception as e:
-        logger.error(f"Stream error: {e}")
         raise HTTPException(500, str(e))
 
 
 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)