Upload 10 files

app.py

@@ -1,717 +1,327 @@
-# app.py - FastAPI version
-
-import json
-import logging
-import os
-from typing import Dict, Any, Optional, List, Union
-from dataclasses import dataclass, asdict
-from contextlib import asynccontextmanager
-import uuid
-from datetime import datetime, timedelta
-
-from fastapi import FastAPI, HTTPException, Depends, status, BackgroundTasks
-from fastapi.middleware.cors import CORSMiddleware
-from fastapi.responses import JSONResponse
-from pydantic import BaseModel, Field, validator
-from openai import OpenAI, AsyncOpenAI
-from dotenv import load_dotenv
-import asyncio
-from cachetools import TTLCache
-
-# Import your modules
-from easy_agents import EASYFARMS_FUNCTION_SCHEMAS, EasyFarmsAgent, execute_easyfarms_function
-from alert import chat_with_weather_assistant, WEATHER_TOOLS
-
-# Configure logging
-logging.basicConfig(level=logging.INFO)
-logger = logging.getLogger(__name__)
-
-# Load environment variables
-load_dotenv()
-
-# ===================== Configuration =====================
-
-@dataclass
-class Config:
-    """Configuration settings"""
-    api_key: str
-    api_url: str
-    model_name: str
-    max_retries: int = 3
-    temperature: float = 0.7
-    
-    @classmethod
-    def from_env(cls):
-        """Load configuration from environment variables"""
-        return cls(
-            api_key=os.getenv("API_KEY"),
-            api_url=os.getenv("API_URL"),
-            model_name=os.getenv("MODEL_NAME", "gpt-4-turbo-preview")
-        )
-
-# ===================== Pydantic Models =====================
-
-class QueryRequest(BaseModel):
-    """Request model for query endpoint"""
-    message: str = Field(..., min_length=1, max_length=5000, description="User's query message")
-    session_id: Optional[str] = Field(None, description="Session ID for conversation continuity")
-    save_history: bool = Field(True, description="Whether to save this interaction in history")
-    
-    class Config:
-        schema_extra = {
-            "example": {
-                "message": "What crop should I grow with N=80, P=45, K=120, temperature 25°C, humidity 70%?",
-                "session_id": "123e4567-e89b-12d3-a456-426614174000",
-                "save_history": True
-            }
-        }
-
-class QueryResponse(BaseModel):
-    """Response model for query endpoint"""
-    response: str
-    session_id: str
-    timestamp: datetime
-    function_calls: Optional[List[Dict[str, Any]]] = None
-    
-    class Config:
-        schema_extra = {
-            "example": {
-                "response": "Based on the soil conditions...",
-                "session_id": "123e4567-e89b-12d3-a456-426614174000",
-                "timestamp": "2024-01-15T10:30:00",
-                "function_calls": []
-            }
-        }
-
-class CropRecommendationRequest(BaseModel):
-    """Request model for crop recommendation"""
-    nitrogen: int = Field(..., ge=0, le=200, description="Nitrogen content (N)")
-    phosphorus: int = Field(..., ge=0, le=200, description="Phosphorus content (P)")
-    potassium: int = Field(..., ge=0, le=200, description="Potassium content (K)")
-    temperature: float = Field(..., ge=-10, le=50, description="Temperature in Celsius")
-    humidity: float = Field(..., ge=0, le=100, description="Humidity percentage")
-    ph: float = Field(6.5, ge=0, le=14, description="Soil pH value")
-    
-    class Config:
-        schema_extra = {
-            "example": {
-                "nitrogen": 80,
-                "phosphorus": 45,
-                "potassium": 120,
-                "temperature": 25.0,
-                "humidity": 70.0,
-                "ph": 6.5
-            }
-        }
-
-class FertilizerRecommendationRequest(BaseModel):
-    """Request model for fertilizer recommendation"""
-    crop: str = Field(..., description="Crop type")
-    soil_type: str = Field(..., description="Type of soil")
-    nitrogen: int = Field(..., ge=0, le=200, description="Current nitrogen content")
-    phosphorus: int = Field(..., ge=0, le=200, description="Current phosphorus content")
-    potassium: int = Field(..., ge=0, le=200, description="Current potassium content")
-    temperature: Optional[float] = Field(None, description="Temperature in Celsius")
-    humidity: Optional[float] = Field(None, description="Humidity percentage")
-    moisture: Optional[float] = Field(None, description="Soil moisture percentage")
-
-class WeatherAlertRequest(BaseModel):
-    """Request model for weather alerts"""
-    location: Optional[str] = Field(None, description="Location for weather alert")
-    include_forecast: bool = Field(True, description="Include weather forecast")
-
-class PlantDiseaseRequest(BaseModel):
-    """Request model for plant disease detection"""
-    symptoms: str = Field(..., description="Description of plant symptoms")
-    crop_type: Optional[str] = Field(None, description="Type of crop affected")
-    image_url: Optional[str] = Field(None, description="URL to plant image")
-
-class SessionInfo(BaseModel):
-    """Session information"""
-    session_id: str
-    created_at: datetime
-    last_activity: datetime
-    message_count: int
-    
-class HealthResponse(BaseModel):
-    """Health check response"""
-    status: str
-    version: str
-    timestamp: datetime
-
-# ===================== Session Manager =====================
-
-class SessionManager:
-    """Manages user sessions and conversation history"""
-    
-    def __init__(self, ttl_hours: int = 24):
-        self.sessions: Dict[str, Dict[str, Any]] = {}
-        self.ttl = timedelta(hours=ttl_hours)
-    
-    def create_session(self) -> str:
-        """Create a new session"""
-        session_id = str(uuid.uuid4())
-        self.sessions[session_id] = {
-            "id": session_id,
-            "created_at": datetime.now(),
-            "last_activity": datetime.now(),
-            "history": [],
-            "message_count": 0
-        }
-        return session_id
-    
-    def get_session(self, session_id: str) -> Optional[Dict[str, Any]]:
-        """Get session by ID"""
-        if session_id in self.sessions:
-            session = self.sessions[session_id]
-            # Check if session has expired
-            if datetime.now() - session["last_activity"] > self.ttl:
-                del self.sessions[session_id]
-                return None
-            session["last_activity"] = datetime.now()
-            return session
-        return None
-    
-    def update_session(self, session_id: str, history_entry: Dict[str, Any]):
-        """Update session history"""
-        if session_id in self.sessions:
-            self.sessions[session_id]["history"].append(history_entry)
-            self.sessions[session_id]["message_count"] += 1
-            self.sessions[session_id]["last_activity"] = datetime.now()
-    
-    def clear_session(self, session_id: str):
-        """Clear session history"""
-        if session_id in self.sessions:
-            self.sessions[session_id]["history"] = []
-            self.sessions[session_id]["message_count"] = 0
-    
-    def cleanup_expired_sessions(self):
-        """Remove expired sessions"""
-        current_time = datetime.now()
-        expired = [
-            sid for sid, session in self.sessions.items()
-            if current_time - session["last_activity"] > self.ttl
-        ]
-        for sid in expired:
-            del self.sessions[sid]
-        return len(expired)
-
-# ===================== EasyFarms Assistant =====================
-
-class EasyFarmsAssistant:
-    """Enhanced EasyFarms AI Assistant with async support"""
-    
-    def __init__(self, config: Optional[Config] = None):
-        """Initialize the assistant with configuration"""
-        self.config = config or Config.from_env()
-        
-        # Async client for FastAPI
-        self.async_client = AsyncOpenAI(
-            api_key=self.config.api_key,
-            base_url=self.config.api_url
-        )
-        
-        # Sync client for backward compatibility
-        self.sync_client = OpenAI(
-            api_key=self.config.api_key,
-            base_url=self.config.api_url
-        )
-        
-        # Initialize tools
-        self.tools = self._initialize_tools()
-        
-        # System prompts
-        self.system_prompt = """
-You are the HAl AI assistant for EasyForms Agritech Solutions. Your task is to provide users with clear, concise, and actionable responses regarding agriculture, crop management, production, treatment, weather alerts, and related queries.
-
-Core Capabilities:
-- Crop recommendations based on soil and weather conditions
-- Fertilizer recommendations for specific crops
-- Plant disease detection and treatment advice
-- Weather alerts and forecasts for farming decisions
-- General agricultural guidance
-
-Rules:
-1. Check if any relevant function_tools or datasets are available for this query.
-2. If available, use the functions to fetch information and generate the final user-facing response.
-3. If the functions or data are unavailable, do not stop; instead, generate a general, well-reasoned response based on your own knowledge.
-4. Keep the response simple, smooth, well-pointed, and concise.
-5. Structure the response with bullet points or numbered steps where helpful.
-6. Provide practical, actionable advice a user can implement immediately.
-7. Use English or Hindi based on user preference.
-8. If any information is uncertain, mention it clearly and suggest alternatives.
-9. For weather-related queries, prioritize safety and timely alerts.
-"""
-        
-        self.final_system = """
-You are the final response assistant for EasyForms Agritech Solutions and your name is HAL AI. Use the outputs from previous function calls to generate a clear, concise, actionable response for the user.
-
-Rules:
-1. Combine the function outputs and your own reasoning to answer the query.
-2. Keep responses simple, smooth, well-pointed, and concise.
-3. Structure response with headings or bullet points if helpful.
-4. Provide practical advice that a farmer or user can implement immediately.
-5. If some data is missing, clearly state it and offer alternatives.
-6. Use English or Hindi based on the user preference.
-7. For weather alerts, emphasize urgency and protective measures.
-"""
-        
-        # Cache for function results
-        self.cache = TTLCache(maxsize=100, ttl=300)  # 5 minute cache
-    
-    def _initialize_tools(self) -> List[Dict]:
-        """Initialize and convert function schemas to new tools format"""
-        tools = []
-        
-        # Convert EasyFarms schemas
-        for schema in EASYFARMS_FUNCTION_SCHEMAS:
-            tool = {
-                "type": "function",
-                "function": {
-                    "name": schema["name"],
-                    "description": schema["description"],
-                    "parameters": schema["parameters"]
-                }
-            }
-            tools.append(tool)
-        
-        # Add weather tools
-        tools.extend(WEATHER_TOOLS)
-        
-        return tools
-    
-    async def call_function_async(self, function_name: str, arguments: Dict) -> Any:
-        """Async version of function calling"""
-        try:
-            # Check cache first
-            cache_key = f"{function_name}:{json.dumps(arguments, sort_keys=True)}"
-            if cache_key in self.cache:
-                logger.info(f"Cache hit for {function_name}")
-                return self.cache[cache_key]
-            
-            # Execute function in thread pool to avoid blocking
-            loop = asyncio.get_event_loop()
-            
-            if function_name.startswith("get_weather"):
-                result = await loop.run_in_executor(
-                    None, 
-                    self._execute_weather_function, 
-                    function_name, 
-                    arguments
-                )
-            else:
-                result = await loop.run_in_executor(
-                    None,
-                    execute_easyfarms_function,
-                    function_name,
-                    arguments
-                )
-            
-            # Cache result
-            self.cache[cache_key] = result
-            return result
-            
-        except Exception as e:
-            logger.error(f"Error executing function {function_name}: {e}")
-            return {"error": str(e)}
-    
-    def _execute_weather_function(self, function_name: str, kwargs: Dict):
-        """Execute weather functions"""
-        from alert import execute_function
-        return execute_function(function_name, kwargs)
-    
-    async def process_query_async(
-        self, 
-        user_message: str, 
-        conversation_history: List[Dict[str, Any]] = None
-    ) -> Dict[str, Any]:
-        """Process user query asynchronously"""
-        try:
-            messages = [
-                {"role": "system", "content": self.system_prompt},
-                {"role": "user", "content": user_message}
-            ]
-            
-            # Add conversation history if exists
-            if conversation_history:
-                # Include last 5 interactions for context
-                messages = [messages[0]] + conversation_history[-10:] + [messages[1]]
-            
-            # First API call
-            response = await self.async_client.chat.completions.create(
-                model=self.config.model_name,
-                messages=messages,
-                tools=self.tools,
-                tool_choice="auto",
-                temperature=self.config.temperature
-            )
-            
-            message = response.choices[0].message
-            function_calls_made = []
-            
-            # Check if tool needs to be called
-            if hasattr(message, 'tool_calls') and message.tool_calls:
-                messages.append(message)
-                
-                # Execute all tool calls
-                for tool_call in message.tool_calls:
-                    function_name = tool_call.function.name
-                    function_args = json.loads(tool_call.function.arguments)
-                    
-                    logger.info(f"Calling function: {function_name} with args: {function_args}")
-                    
-                    # Call function asynchronously
-                    function_result = await self.call_function_async(function_name, function_args)
-                    
-                    function_calls_made.append({
-                        "name": function_name,
-                        "arguments": function_args,
-                        "result": function_result
-                    })
-                    
-                    # Add function result to messages
-                    messages.append({
-                        "role": "tool",
-                        "tool_call_id": tool_call.id,
-                        "content": json.dumps(function_result)
-                    })
-                
-                # Add final system prompt
-                messages.append({
-                    "role": "system",
-                    "content": self.final_system
-                })
-                
-                # Get final response
-                final_response = await self.async_client.chat.completions.create(
-                    model=self.config.model_name,
-                    messages=messages,
-                    temperature=self.config.temperature
-                )
-                
-                response_content = final_response.choices[0].message.content
-            else:
-                response_content = message.content
-            
-            return {
-                "response": response_content,
-                "function_calls": function_calls_made
-            }
-            
-        except Exception as e:
-            logger.error(f"Error processing query: {e}")
-            raise HTTPException(
-                status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-                detail=f"Error processing query: {str(e)}"
-            )
-
-# ===================== FastAPI App =====================
-
-# App lifespan manager
-@asynccontextmanager
-async def lifespan(app: FastAPI):
-    """Manage app lifecycle"""
-    # Startup
-    logger.info("Starting EasyFarms API...")
-    app.state.assistant = EasyFarmsAssistant()
-    app.state.session_manager = SessionManager()
-    
-    # Background task to cleanup sessions
-    async def cleanup_sessions():
-        while True:
-            await asyncio.sleep(3600)  # Run every hour
-            expired = app.state.session_manager.cleanup_expired_sessions()
-            if expired > 0:
-                logger.info(f"Cleaned up {expired} expired sessions")
-    
-    # Start background task
-    cleanup_task = asyncio.create_task(cleanup_sessions())
-    
-    yield
-    
-    # Shutdown
-    cleanup_task.cancel()
-    logger.info("Shutting down EasyFarms API...")
-
-# Create FastAPI app
-app = FastAPI(
-    title="EasyFarms Agricultural Assistant API",
-    description="AI-powered agricultural assistant for crop management, fertilizer recommendations, and weather alerts",
-    version="1.0.0",
-    lifespan=lifespan
-)
-
-# Add CORS middleware
-app.add_middleware(
-    CORSMiddleware,
-    allow_origins=["*"],  # Configure appropriately for production
-    allow_credentials=True,
-    allow_methods=["*"],
-    allow_headers=["*"],
-)
-
-# ===================== Dependencies =====================
-
-def get_assistant() -> EasyFarmsAssistant:
-    """Get assistant instance"""
-    return app.state.assistant
-
-def get_session_manager() -> SessionManager:
-    """Get session manager instance"""
-    return app.state.session_manager
-
-# ===================== API Endpoints =====================
-
-@app.get("/", response_model=HealthResponse)
-async def root():
-    """Root endpoint - health check"""
-    return HealthResponse(
-        status="healthy",
-        version="1.0.0",
-        timestamp=datetime.now()
-    )
-
-@app.get("/health", response_model=HealthResponse)
-async def health_check():
-    """Health check endpoint"""
-    return HealthResponse(
-        status="healthy",
-        version="1.0.0",
-        timestamp=datetime.now()
-    )
-
-@app.post("/api/query", response_model=QueryResponse)
-async def process_query(
-    request: QueryRequest,
-    assistant: EasyFarmsAssistant = Depends(get_assistant),
-    session_manager: SessionManager = Depends(get_session_manager)
-):
-    """
-    Process a general query to the agricultural assistant
-    """
-    # Handle session
-    if request.session_id:
-        session = session_manager.get_session(request.session_id)
-        if not session:
-            request.session_id = session_manager.create_session()
-            session = session_manager.get_session(request.session_id)
-    else:
-        request.session_id = session_manager.create_session()
-        session = session_manager.get_session(request.session_id)
-    
-    # Process query
-    result = await assistant.process_query_async(
-        request.message,
-        conversation_history=session["history"] if session else None
-    )
-    
-    # Update session history if requested
-    if request.save_history and session:
-        session_manager.update_session(
-            request.session_id,
-            {"role": "user", "content": request.message}
-        )
-        session_manager.update_session(
-            request.session_id,
-            {"role": "assistant", "content": result["response"]}
-        )
-    
-    return QueryResponse(
-        response=result["response"],
-        session_id=request.session_id,
-        timestamp=datetime.now(),
-        function_calls=result.get("function_calls")
-    )
-
-@app.post("/api/crop-recommendation")
-async def get_crop_recommendation(
-    request: CropRecommendationRequest,
-    assistant: EasyFarmsAssistant = Depends(get_assistant)
-):
-    """
-    Get crop recommendation based on soil and weather conditions
-    """
-    query = f"What crop should I grow with N={request.nitrogen}, P={request.phosphorus}, K={request.potassium}, temperature {request.temperature}°C, humidity {request.humidity}%, pH {request.ph}?"
-    
-    result = await assistant.process_query_async(query)
-    
-    return {
-        "recommendation": result["response"],
-        "input_parameters": request.dict(),
-        "timestamp": datetime.now()
-    }
-
-@app.post("/api/fertilizer-recommendation")
-async def get_fertilizer_recommendation(
-    request: FertilizerRecommendationRequest,
-    assistant: EasyFarmsAssistant = Depends(get_assistant)
-):
-    """
-    Get fertilizer recommendation for specific crop and soil conditions
-    """
-    query_parts = [
-        f"I need fertilizer recommendation for {request.crop} in {request.soil_type} soil",
-        f"with N={request.nitrogen}, P={request.phosphorus}, K={request.potassium}"
-    ]
-    
-    if request.temperature:
-        query_parts.append(f"temperature {request.temperature}°C")
-    if request.humidity:
-        query_parts.append(f"humidity {request.humidity}%")
-    if request.moisture:
-        query_parts.append(f"moisture {request.moisture}%")
-    
-    query = ", ".join(query_parts)
-    result = await assistant.process_query_async(query)
-    
-    return {
-        "recommendation": result["response"],
-        "crop": request.crop,
-        "soil_type": request.soil_type,
-        "timestamp": datetime.now()
-    }
-
-@app.post("/api/weather-alert")
-async def get_weather_alert(
-    request: WeatherAlertRequest,
-    assistant: EasyFarmsAssistant = Depends(get_assistant)
-):
-    """
-    Get weather alerts for farming
-    """
-    location_str = f" for {request.location}" if request.location else ""
-    query = f"What are the current weather alerts and conditions{location_str}? How will this affect farming?"
-    
-    if request.include_forecast:
-        query += " Include the weather forecast."
-    
-    result = await assistant.process_query_async(query)
-    
-    return {
-        "alerts": result["response"],
-        "location": request.location or "Default location",
-        "timestamp": datetime.now()
-    }
-
-@app.post("/api/plant-disease")
-async def detect_plant_disease(
-    request: PlantDiseaseRequest,
-    assistant: EasyFarmsAssistant = Depends(get_assistant)
-):
-    """
-    Detect plant disease based on symptoms
-    """
-    query_parts = [f"My plants have these symptoms: {request.symptoms}"]
-    
-    if request.crop_type:
-        query_parts.append(f"The crop is {request.crop_type}.")
-    
-    query_parts.append("What could be the problem and how should I treat it?")
-    
-    query = " ".join(query_parts)
-    result = await assistant.process_query_async(query)
-    
-    return {
-        "diagnosis": result["response"],
-        "symptoms": request.symptoms,
-        "crop_type": request.crop_type,
-        "timestamp": datetime.now()
-    }
-
-@app.get("/api/session/{session_id}")
-async def get_session_info(
-    session_id: str,
-    session_manager: SessionManager = Depends(get_session_manager)
-):
-    """
-    Get information about a specific session
-    """
-    session = session_manager.get_session(session_id)
-    
-    if not session:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Session not found or expired"
-        )
-    
-    return SessionInfo(
-        session_id=session["id"],
-        created_at=session["created_at"],
-        last_activity=session["last_activity"],
-        message_count=session["message_count"]
-    )
-
-@app.delete("/api/session/{session_id}")
-async def clear_session(
-    session_id: str,
-    session_manager: SessionManager = Depends(get_session_manager)
-):
-    """
-    Clear session history
-    """
-    session = session_manager.get_session(session_id)
-    
-    if not session:
-        raise HTTPException(
-            status_code=status.HTTP_404_NOT_FOUND,
-            detail="Session not found or expired"
-        )
-    
-    session_manager.clear_session(session_id)
-    
-    return {"message": "Session history cleared", "session_id": session_id}
-
-@app.get("/api/supported-options")
-async def get_supported_options(
-    assistant: EasyFarmsAssistant = Depends(get_assistant)
-):
-    """
-    Get all supported options for crops, fertilizers, etc.
-    """
-    result = await assistant.process_query_async("Show me all supported crop types and options")
-    
-    return {
-        "options": result["response"],
-        "timestamp": datetime.now()
-    }
-
-# ===================== Error Handlers =====================
-
-@app.exception_handler(HTTPException)
-async def http_exception_handler(request, exc):
-    """Handle HTTP exceptions"""
-    return JSONResponse(
-        status_code=exc.status_code,
-        content={
-            "error": exc.detail,
-            "status_code": exc.status_code,
-            "timestamp": datetime.now().isoformat()
-        }
-    )
-
-@app.exception_handler(Exception)
-async def general_exception_handler(request, exc):
-    """Handle general exceptions"""
-    logger.error(f"Unhandled exception: {exc}")
-    return JSONResponse(
-        status_code=status.HTTP_500_INTERNAL_SERVER_ERROR,
-        content={
-            "error": "Internal server error",
-            "status_code": 500,
-            "timestamp": datetime.now().isoformat()
-        }
-    )
-
-# ===================== Main =====================
-
-if __name__ == "__main__":
-    import uvicorn
-    
-    # Run the FastAPI app
-    uvicorn.run(
-        "app:app",
-        host="0.0.0.0",
-        port=7860,
-        reload=True,
-        log_level="info"
-    )
+# app.py
+
+import json
+import openai
+from typing import Dict, Any, Optional, List
+from dataclasses import dataclass
+import logging
+from openai import OpenAI
+from dotenv import load_dotenv
+import os
+
+# Import your modules
+from easy_agents import EASYFARMS_FUNCTION_SCHEMAS, execute_easyfarms_function
+from alert import WEATHER_TOOLS , execute_function
+from conversation_manager import ConversationManager
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Load environment variables
+load_dotenv()
+
+@dataclass
+class Config:
+    """Configuration settings"""
+    api_key: str
+    api_url: str
+    model_name: str
+    max_retries: int = 3
+    temperature: float = 0.5
+    
+    @classmethod
+    def from_env(cls):
+        """Load configuration from environment variables"""
+        return cls(
+            api_key=os.getenv("API_KEY"),
+            api_url=os.getenv("API_URL"),
+            model_name=os.getenv("MODEL_NAME")
+        )
+
+class EasyFarmsAssistant:
+    """Enhanced EasyFarms AI Assistant with weather integration and persistent sessions"""
+    
+    def __init__(self, config: Optional[Config] = None, manager: Optional[ConversationManager] = None):
+        """
+        Initialize the assistant with configuration and a conversation manager.
+        
+        Args:
+            config (Optional[Config]): Configuration object. If None, loads from environment.
+            manager (Optional[ConversationManager]): Manager for handling conversation persistence.
+        """
+        self.config = config or Config.from_env()
+        
+        # Validate configuration
+        if not all([self.config.api_key, self.config.api_url, self.config.model_name]):
+            raise ValueError("Missing required configuration: API_KEY, API_URL, and MODEL_NAME must be set")
+        
+        self.client = OpenAI(
+            api_key=self.config.api_key,
+            base_url=self.config.api_url
+        )
+        
+        # All available functions from both modules are combined into the tools list
+        self.tools = self._initialize_tools()
+        
+        # Use the provided conversation manager or create a new one
+        self.manager = manager or ConversationManager()
+        
+        # System prompts
+        self.system_prompt = """You are the AI assistant for EasyForms Agritech Solutions. Your task is to provide users with clear, concise, and actionable responses regarding agriculture, crop management, production, treatment, weather alerts, and related queries.
+
+Core Capabilities:
+- Crop recommendations based on soil and weather conditions
+- Fertilizer recommendations for specific crops
+- Plant disease detection and treatment advice
+- Weather alerts and forecasts for farming decisions
+- Market data and commodity prices
+- General agricultural guidance
+
+Rules:
+1. Check if any relevant function_tools or datasets are available for this query.
+2. If available, use the functions to fetch information and generate the final user-facing response.
+3. If the functions or data are unavailable, do **not stop**; instead, generate a general, well-reasoned response based on your own knowledge.
+4. Keep the response **simple, smooth, well-pointed, and concise**.
+5. Structure the response with bullet points or numbered steps where helpful.
+6. Provide practical, actionable advice a user can implement immediately.
+7. Use English or Hindi based on user preference.
+8. If any information is uncertain, mention it clearly and suggest alternatives.
+9. For weather-related queries, prioritize safety and timely alerts."""
+        
+        self.final_system = """You are the final response assistant for EasyForms Agritech Solutions. Use the outputs from previous function calls to generate a **clear, concise, actionable response** for the user.
+
+Rules:
+1. Combine the function outputs and your own reasoning to answer the query.
+2. Keep responses simple, smooth, well-pointed, and concise.
+3. Structure response with headings or bullet points if helpful.
+4. Provide practical advice that a farmer or user can implement immediately.
+5. If some data is missing, clearly state it and offer alternatives.
+6. Use English or Hindi based on the user preference.
+7. For weather alerts, emphasize urgency and protective measures."""
+    
+    def _initialize_tools(self) -> List[Dict]:
+        """Initialize and convert all function schemas to the new tools format"""
+        tools = []
+        
+        # Convert EasyFarms schemas to the new format
+        for schema in EASYFARMS_FUNCTION_SCHEMAS:
+            tool = {
+                "type": "function",
+                "function": {
+                    "name": schema["name"],
+                    "description": schema["description"],
+                    "parameters": schema["parameters"]
+                }
+            }
+            tools.append(tool)
+        
+        # Add weather tools (which are already in the correct format)
+        tools.extend(WEATHER_TOOLS)
+        
+        return tools
+    
+    def call_function(self, function_name: str, arguments: Dict) -> Any:
+        """Route function calls to appropriate handlers with error handling"""
+        try:
+            # Map all available function names to their handlers
+            function_map = {
+                # EasyFarms functions
+                "get_crop_recommendation": lambda args: execute_easyfarms_function("get_crop_recommendation", **args),
+                "get_fertilizer_recommendation": lambda args: execute_easyfarms_function("get_fertilizer_recommendation", **args),
+                "detect_plant_disease": lambda args: execute_easyfarms_function("detect_plant_disease", **args),
+                "get_supported_options": lambda args: execute_easyfarms_function("get_supported_options", **args),
+                "get_market_prices": lambda args: execute_easyfarms_function("get_market_prices", **args),
+                "compare_commodity_prices": lambda args: execute_easyfarms_function("compare_commodity_prices", **args),
+                "get_market_locations": lambda args: execute_easyfarms_function("get_market_locations", **args),
+                "get_commodity_list": lambda args: execute_easyfarms_function("get_commodity_list", **args),
+                
+                # Weather alert functions
+                "get_weather_alerts": lambda args: self._execute_weather_function("get_weather_alerts", **args),
+                "get_weather": lambda args: self._execute_weather_function("get_weather", **args),
+                "get_alert_summary": lambda args: self._execute_weather_function("get_alert_summary", **args),
+                "get_available_locations": lambda args: self._execute_weather_function("get_available_locations", **args)
+            }
+            
+            if function_name in function_map:
+                return function_map[function_name](arguments)
+            else:
+                return {"error": f"Unknown function: {function_name}"}
+                
+        except Exception as e:
+            logger.error(f"Error executing function {function_name}: {e}")
+            return {"error": str(e)}
+    
+    def _execute_weather_function(self, function_name: str, **kwargs):
+        """Helper to execute weather functions from the alert.py module"""
+        from alert import execute_function
+        return execute_function(function_name, kwargs)
+    
+    def process_query(self, user_message: str, session_id: str, image_url: Optional[str] = None) -> str:
+        """
+        Process user query, correctly reformatting history for the LLM API call.
+        """
+        try:
+            # MEMORY STEP 1: Fetch the complete past conversation using the session_id.
+            conversation_history = self.manager.get_history(session_id)
+            
+            # Prepare the list that will be sent to the AI
+            messages = [{"role": "system", "content": self.system_prompt}]
+
+            # MEMORY STEP 2: Loop through the history and add every past message.
+            # This builds the AI's memory of what was said before.
+            for message in conversation_history:
+                if message.get("role") == "user":
+                    llm_user_content = message.get("content", "")
+                    if message.get("imageUrl"):
+                        llm_user_content += f" [image_url: {message.get('imageUrl')}]"
+                    messages.append({"role": "user", "content": llm_user_content})
+                elif message.get("role") == "assistant":
+                    messages.append({"role": "assistant", "content": message.get("content", "")})
+            
+            # MEMORY STEP 3: Add the user's CURRENT message to the end of the history.
+            llm_message_content = user_message
+            if image_url:
+                llm_message_content += f" [image_url: {image_url}]"
+            messages.append({"role": "user", "content": llm_message_content})
+            
+            # MEMORY STEP 4: Send the entire 'messages' list to the AI.
+            response = self.client.chat.completions.create(
+                model=self.config.model_name,
+                messages=messages,
+                tools=self.tools,
+                tool_choice="auto",
+                temperature=self.config.temperature
+            )
+            
+            message = response.choices[0].message
+            
+            if hasattr(message, 'tool_calls') and message.tool_calls:
+                # Add the assistant's message with tool calls
+                messages.append({
+                    "role": "assistant",
+                    "tool_calls": [
+                        {
+                            "id": tool_call.id,
+                            "type": "function", 
+                            "function": {
+                                "name": tool_call.function.name,
+                                "arguments": tool_call.function.arguments
+                            }
+                        } for tool_call in message.tool_calls
+                    ]
+                })
+                
+                # Execute all tool calls
+                for tool_call in message.tool_calls:
+                    function_name = tool_call.function.name
+                    function_args = json.loads(tool_call.function.arguments)
+                    
+                    logger.info(f"Calling function: {function_name} with args: {function_args}")
+                    
+                    # Call the function
+                    function_result = self.call_function(function_name, function_args)
+                    
+                    # Add function result to messages
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tool_call.id,
+                        "content": json.dumps(function_result)
+                    })
+                
+                # Add final system prompt for generating response
+                messages.append({
+                    "role": "system",
+                    "content": self.final_system
+                })
+                
+                # Get final response
+                final_response = self.client.chat.completions.create(
+                    model=self.config.model_name,
+                    messages=messages,
+                    temperature=self.config.temperature
+                )
+                response_content = final_response.choices[0].message.content
+            else:
+                response_content = message.content
+
+            # After getting the response, save the new turns back to the database for the next message.
+            user_turn_for_storage = {"role": "user", "content": user_message}
+            if image_url:
+                user_turn_for_storage["imageUrl"] = image_url
+
+            updated_history = conversation_history + [
+                user_turn_for_storage,
+                {"role": "assistant", "content": response_content}
+            ]
+            self.manager.save_history(session_id, updated_history)
+            
+            return response_content
+            
+        except Exception as e:
+            logger.error(f"Error processing query for session {session_id}: {e}")
+            return f"I apologize, but I encountered an error: {str(e)}. Please try again or rephrase your question."
+            
+    def clear_history(self, session_id: str) -> bool:
+        """
+        Clear conversation history for a specific session from the database.
+        
+        Args:
+            session_id: The ID of the session to clear.
+        
+        Returns:
+            True if deletion was successful, False otherwise.
+        """
+        logger.info(f"Clearing history for session: {session_id}")
+        return self.manager.delete_history(session_id)
+
+# Utility class for generating example queries (can be used for testing)
+class QuickQueries:
+    """Pre-defined query templates for common farming questions"""
+    
+    @staticmethod
+    def crop_recommendation(N: int, P: int, K: int, temp: float, humidity: float, ph: float = 6.5) -> str:
+        """Generate crop recommendation query"""
+        return f"What crop should I grow with N={N}, P={P}, K={K}, temperature {temp}°C, humidity {humidity}%, pH {ph}?"
+    
+    @staticmethod
+    def fertilizer_query(crop: str, soil: str, N: int, P: int, K: int) -> str:
+        """Generate fertilizer recommendation query"""
+        return f"I need fertilizer recommendation for {crop} in {soil} soil with N={N}, P={P}, K={K}"
+    
+    @staticmethod
+    def weather_alert(location: str = "") -> str:
+        """Generate weather alert query"""
+        location_str = f" for {location}" if location else ""
+        return f"What are the current weather alerts and conditions{location_str}? How will this affect farming?"
+
+# Test function to validate configuration
+def test_configuration():
+    """Test if all configuration is properly set up"""
+    try:
+        # Check environment variables
+        required_env_vars = ["API_KEY", "API_URL", "MODEL_NAME"]
+        missing_vars = [var for var in required_env_vars if not os.getenv(var)]
+        
+        if missing_vars:
+            print(f"❌ Missing environment variables: {missing_vars}")
+            return False
+        
+        # Test assistant initialization
+        assistant = EasyFarmsAssistant()
+        print("✅ Assistant initialized successfully")
+        
+        # Test function schemas
+        print(f"✅ Loaded {len(assistant.tools)} function tools")
+        
+        return True
+    except Exception as e:
+        print(f"❌ Configuration test failed: {e}")
+        return False
+
+if __name__ == "__main__":
+    print("=== EasyFarms Assistant Configuration Test ===")
+    if test_configuration():
+        print("✅ All systems ready!")
+    else:
+        print("❌ Please fix configuration issues before running the assistant.")

conversation_manager.py

@@ -0,0 +1,70 @@
+# conversation_manager.py
+
+import os
+from supabase import create_client, Client
+from typing import List, Dict, Any, Optional
+import logging
+
+logger = logging.getLogger(__name__)
+
+class ConversationManager:
+    def __init__(self):
+        """Initializes the Supabase client."""
+        supabase_url = os.getenv("SUPABASE_URL")
+        supabase_key = os.getenv("SUPABASE_KEY")
+        
+        if not supabase_url or not supabase_key:
+            raise ValueError("Supabase URL and Key must be set in environment variables.")
+            
+        self.supabase: Client = create_client(supabase_url, supabase_key)
+        self.table_name = "conversations"
+        logger.info("ConversationManager initialized with Supabase client.")
+
+    def get_history(self, session_id: str) -> List[Dict[str, Any]]:
+        """
+        Retrieves conversation history for a given session_id.
+        Returns an empty list if no history is found.
+        """
+        try:
+            response = self.supabase.table(self.table_name)\
+                .select("history")\
+                .eq("session_id", session_id)\
+                .limit(1)\
+                .execute()
+            
+            if response.data:
+                return response.data[0].get("history", [])
+            return []
+        except Exception as e:
+            logger.error(f"Error fetching history for session {session_id}: {e}")
+            return []
+
+    def save_history(self, session_id: str, history: List[Dict[str, Any]]) -> None:
+        """
+        Saves or updates the conversation history for a session_id.
+        Uses 'upsert' to create a new record or update an existing one.
+        """
+        try:
+            self.supabase.table(self.table_name).upsert({
+                "session_id": session_id,
+                "history": history
+            }).execute()
+            logger.info(f"History for session {session_id} saved successfully.")
+        except Exception as e:
+            logger.error(f"Error saving history for session {session_id}: {e}")
+
+    def delete_history(self, session_id: str) -> bool:
+        """
+        Deletes the conversation history for a given session_id.
+        Returns True on success, False on failure.
+        """
+        try:
+            self.supabase.table(self.table_name)\
+                .delete()\
+                .eq("session_id", session_id)\
+                .execute()
+            logger.info(f"History for session {session_id} deleted successfully.")
+            return True
+        except Exception as e:
+            logger.error(f"Error deleting history for session {session_id}: {e}")
+            return False

easy_agents.py

@@ -1,4 +1,4 @@
-# easy_agents.py
+# easy_agents.py - Enhanced with eNAM Market Data Integration
 
 import json
 import requests
@@ -6,6 +6,9 @@ import logging
 from typing import Optional, Dict, Any, Union, List
 from functools import lru_cache
 import time
+from datetime import datetime
+import os
+import tempfile
 
 # Configure logging
 logging.basicConfig(level=logging.INFO)
@@ -14,6 +17,7 @@ logger = logging.getLogger(__name__)
 class EasyFarmsAgent:
     """
     EasyFarms AI Agent optimized for function calling in AI systems.
+    Now includes eNAM market data integration.
     """
     
     def __init__(self, timeout: int = 30, max_retries: int = 3):
@@ -28,8 +32,17 @@ class EasyFarmsAgent:
             'Accept': 'application/json'
         })
         
+        # eNAM API configuration
+        self.enam_api_key = os.environ.get('ENAM_API_KEY','579b464db66ec23bdd00000117ba747cbf6948354c9afae09a8a5087')
+        self.enam_base_url = "https://api.data.gov.in/resource/9ef84268-d588-465a-a308-a864a43d0070"
+        
         # Load mappings
         self._load_mappings()
+        
+        # Cache for market data
+        self._market_cache = {}
+        self._cache_timestamp = {}
+        self._cache_ttl = 300  # 5 minutes cache
     
     def _load_mappings(self):
         """Pre-load all mappings for faster access."""
@@ -154,15 +167,610 @@ class EasyFarmsAgent:
                 'message': f'Error parsing HTML response: {str(e)}',
                 'raw_html': html_content[:500] + '...'
             }
-
-# Global agent instance
-_easyfarms_agent = EasyFarmsAgent()
+
+    def _is_cache_valid(self, cache_key: str) -> bool:
+        """Check if cached data is still valid."""
+        if cache_key not in self._cache_timestamp:
+            return False
+        elapsed = time.time() - self._cache_timestamp[cache_key]
+        return elapsed < self._cache_ttl
+
+    def _fetch_enam_data(self, params: Dict[str, Any]) -> Dict[str, Any]:
+        """Fetch data from eNAM API with caching."""
+        cache_key = json.dumps(params, sort_keys=True)
+        
+        # Check cache
+        if cache_key in self._market_cache and self._is_cache_valid(cache_key):
+            logger.info("Returning cached market data")
+            return self._market_cache[cache_key]
+        
+        # Fetch fresh data
+        headers = {
+            'Accept': '*/*',
+            'Accept-Language': 'en-IN,en-US;q=0.9,en;q=0.8,hi;q=0.7',
+            'Connection': 'keep-alive',
+            'Origin': 'https://app.easyfarms.in',
+            'Referer': 'https://app.easyfarms.in/',
+            'Sec-Fetch-Dest': 'empty',
+            'Sec-Fetch-Mode': 'cors',
+            'Sec-Fetch-Site': 'cross-site',
+            'User-Agent': 'Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36'
+        }
+        
+        response = self._make_request_with_retry(
+            "GET",
+            self.enam_base_url,
+            params=params,
+            headers=headers
+        )
+        
+        # Cache the response
+        self._market_cache[cache_key] = response
+        self._cache_timestamp[cache_key] = time.time()
+        
+        return response
+
+# Global agent instance
+_easyfarms_agent = EasyFarmsAgent()
+
+# =============================================================================
+# MARKET DATA FUNCTION DEFINITIONS
+# =============================================================================
+
+def get_market_prices(
+    commodity: Optional[str] = None,
+    state: Optional[str] = None,
+    district: Optional[str] = None,
+    market: Optional[str] = None,
+    limit: int = 25
+) -> Dict[str, Any]:
+    """
+    Get current market prices for agricultural commodities from Indian mandis.
+    
+    Args:
+        commodity: Name of the commodity (e.g., "Tomato", "Wheat", "Rice")
+        state: State name (e.g., "Gujarat", "Maharashtra")
+        district: District name
+        market: Market/mandi name
+        limit: Number of records to fetch (default: 25, max: 100)
+    
+    Returns:
+        Dictionary with market price data and statistics
+    """
+    try:
+        params = {
+            'api-key': _easyfarms_agent.enam_api_key,
+            'format': 'json',
+            'limit': min(limit, 100),
+            'offset': 0
+        }
+        
+        # Add filters if provided
+        filters = []
+        if commodity:
+            filters.append(f"commodity:{commodity}")
+        if state:
+            filters.append(f"state:{state}")
+        if district:
+            filters.append(f"district:{district}")
+        if market:
+            filters.append(f"market:{market}")
+        
+        if filters:
+            params['filters'] = ','.join(filters)
+        
+        # Fetch data from eNAM API
+        response = _easyfarms_agent._fetch_enam_data(params)
+        
+        records = response.get('records', [])
+        
+        # Process and analyze the data
+        if records:
+            # Calculate statistics
+            prices = {
+                'min_prices': [],
+                'max_prices': [],
+                'modal_prices': []
+            }
+            
+            for record in records:
+                try:
+                    if 'min_price' in record and record['min_price']:
+                        prices['min_prices'].append(float(record['min_price']))
+                    if 'max_price' in record and record['max_price']:
+                        prices['max_prices'].append(float(record['max_price']))
+                    if 'modal_price' in record and record['modal_price']:
+                        prices['modal_prices'].append(float(record['modal_price']))
+                except (ValueError, TypeError):
+                    continue
+            
+            # Calculate averages
+            stats = {}
+            for price_type, values in prices.items():
+                if values:
+                    stats[price_type] = {
+                        'average': sum(values) / len(values),
+                        'min': min(values),
+                        'max': max(values),
+                        'count': len(values)
+                    }
+            
+            return {
+                'status': 'success',
+                'mode': 'market_prices',
+                'total_records': response.get('total', len(records)),
+                'fetched_records': len(records),
+                'statistics': stats,
+                'records': records[:10],  # Return first 10 records for preview
+                'filters_applied': {
+                    'commodity': commodity,
+                    'state': state,
+                    'district': district,
+                    'market': market
+                }
+            }
+        else:
+            return {
+                'status': 'success',
+                'mode': 'market_prices',
+                'message': 'No records found for the given filters',
+                'filters_applied': {
+                    'commodity': commodity,
+                    'state': state,
+                    'district': district,
+                    'market': market
+                }
+            }
+            
+    except Exception as e:
+        return {
+            'status': 'error',
+            'mode': 'market_prices',
+            'error': str(e)
+        }
+
+def get_commodity_list(
+    state: Optional[str] = None,
+    limit: int = 100
+) -> Dict[str, Any]:
+    """
+    Get list of available commodities in the market data.
+    
+    Args:
+        state: Optional state filter to get commodities specific to a state
+        limit: Number of records to analyze (default: 100)
+    
+    Returns:
+        Dictionary with list of unique commodities and their varieties
+    """
+    try:
+        params = {
+            'api-key': _easyfarms_agent.enam_api_key,
+            'format': 'json',
+            'limit': limit,
+            'offset': 0
+        }
+        
+        if state:
+            params['filters'] = f"state:{state}"
+        
+        response = _easyfarms_agent._fetch_enam_data(params)
+        records = response.get('records', [])
+        
+        # Extract unique commodities and varieties
+        commodities = {}
+        for record in records:
+            commodity = record.get('commodity', '').strip()
+            variety = record.get('variety', '').strip()
+            
+            if commodity:
+                if commodity not in commodities:
+                    commodities[commodity] = set()
+                if variety:
+                    commodities[commodity].add(variety)
+        
+        # Convert sets to sorted lists
+        commodities = {k: sorted(list(v)) for k, v in commodities.items()}
+        
+        return {
+            'status': 'success',
+            'mode': 'commodity_list',
+            'total_commodities': len(commodities),
+            'commodities': commodities,
+            'state_filter': state
+        }
+        
+    except Exception as e:
+        return {
+            'status': 'error',
+            'mode': 'commodity_list',
+            'error': str(e)
+        }
+
+def get_market_locations() -> Dict[str, Any]:
+    """
+    Get hierarchical list of market locations (states -> districts -> markets).
+    
+    Returns:
+        Dictionary with nested structure of market locations
+    """
+    try:
+        params = {
+            'api-key': _easyfarms_agent.enam_api_key,
+            'format': 'json',
+            'limit': 100,
+            'offset': 0
+        }
+        
+        response = _easyfarms_agent._fetch_enam_data(params)
+        records = response.get('records', [])
+        
+        # Build hierarchical structure
+        locations = {}
+        
+        for record in records:
+            state = record.get('state', '').strip()
+            district = record.get('district', '').strip()
+            market = record.get('market', '').strip()
+            
+            if state:
+                if state not in locations:
+                    locations[state] = {}
+                if district:
+                    if district not in locations[state]:
+                        locations[state][district] = set()
+                    if market:
+                        locations[state][district].add(market)
+        
+        # Convert sets to sorted lists
+        for state in locations:
+            for district in locations[state]:
+                locations[state][district] = sorted(list(locations[state][district]))
+        
+        # Calculate totals
+        total_states = len(locations)
+        total_districts = sum(len(districts) for districts in locations.values())
+        total_markets = sum(
+            len(markets) 
+            for state_data in locations.values() 
+            for markets in state_data.values()
+        )
+        
+        return {
+            'status': 'success',
+            'mode': 'market_locations',
+            'total_states': total_states,
+            'total_districts': total_districts,
+            'total_markets': total_markets,
+            'locations': locations
+        }
+        
+    except Exception as e:
+        return {
+            'status': 'error',
+            'mode': 'market_locations',
+            'error': str(e)
+        }
+
+def compare_commodity_prices(
+    commodity: str,
+    states: Optional[List[str]] = None,
+    limit: int = 50
+) -> Dict[str, Any]:
+    """
+    Compare prices of a commodity across different states or markets.
+    
+    Args:
+        commodity: Name of the commodity to compare
+        states: List of states to compare (optional, if not provided compares all)
+        limit: Number of records per state
+    
+    Returns:
+        Dictionary with price comparison data
+    """
+    try:
+        comparison_data = {}
+        
+        if states:
+            # Compare specific states
+            for state in states:
+                params = {
+                    'api-key': _easyfarms_agent.enam_api_key,
+                    'format': 'json',
+                    'limit': limit,
+                    'offset': 0,
+                    'filters': f"commodity:{commodity},state:{state}"
+                }
+                
+                response = _easyfarms_agent._fetch_enam_data(params)
+                records = response.get('records', [])
+                
+                if records:
+                    prices = []
+                    for r in records:
+                        modal_price = r.get('modal_price')
+                        if modal_price:
+                            try:
+                                price = float(modal_price)
+                                if price > 0:
+                                    prices.append(price)
+                            except (ValueError, TypeError):
+                                continue
+                    
+                    if prices:
+                        comparison_data[state] = {
+                            'average_price': sum(prices) / len(prices),
+                            'min_price': min(prices),
+                            'max_price': max(prices),
+                            'sample_count': len(prices),
+                            'sample_markets': list(set(r.get('market', '') for r in records[:5] if r.get('market')))
+                        }
+        else:
+            # Get data for all states
+            params = {
+                'api-key': _easyfarms_agent.enam_api_key,
+                'format': 'json',
+                'limit': 100,
+                'offset': 0,
+                'filters': f"commodity:{commodity}"
+            }
+            
+            response = _easyfarms_agent._fetch_enam_data(params)
+            records = response.get('records', [])
+            
+            # Group by state
+            state_data = {}
+            for record in records:
+                state = record.get('state', '')
+                if state:
+                    if state not in state_data:
+                        state_data[state] = []
+                    modal_price = record.get('modal_price')
+                    if modal_price:
+                        try:
+                            price = float(modal_price)
+                            if price > 0:
+                                state_data[state].append(price)
+                        except (ValueError, TypeError):
+                            continue
+            
+            # Calculate statistics per state
+            for state, prices in state_data.items():
+                if prices:
+                    comparison_data[state] = {
+                        'average_price': sum(prices) / len(prices),
+                        'min_price': min(prices),
+                        'max_price': max(prices),
+                        'sample_count': len(prices)
+                    }
+        
+        # Find best and worst prices
+        if comparison_data:
+            avg_prices = {state: data['average_price'] for state, data in comparison_data.items()}
+            best_state = min(avg_prices, key=avg_prices.get)
+            worst_state = max(avg_prices, key=avg_prices.get)
+            
+            return {
+                'status': 'success',
+                'mode': 'price_comparison',
+                'commodity': commodity,
+                'comparison_data': comparison_data,
+                'summary': {
+                    'best_price_state': best_state,
+                    'best_average_price': avg_prices[best_state],
+                    'worst_price_state': worst_state,
+                    'worst_average_price': avg_prices[worst_state],
+                    'price_range': avg_prices[worst_state] - avg_prices[best_state],
+                    'states_compared': len(comparison_data)
+                }
+            }
+        else:
+            return {
+                'status': 'success',
+                'mode': 'price_comparison',
+                'commodity': commodity,
+                'message': 'No price data found for the specified commodity'
+            }
+            
+    except Exception as e:
+        return {
+            'status': 'error',
+            'mode': 'price_comparison',
+            'error': str(e)
+        }
+
+def get_crop_recommendation(
+    N: int,
+    P: int, 
+    K: int,
+    temperature: float,
+    humidity: float,
+    ph: float = None,
+    rainfall: float = 100
+) -> Dict[str, Any]:
+    try:
+        data = {
+            "N": N, "P": P, "K": K,
+            "temperature": temperature,
+            "humidity": humidity,
+            "ph": ph if ph is not None else 6.5,
+            "rainfall": rainfall
+        }
+        
+        response = _easyfarms_agent._make_request_with_retry(
+            "POST", 
+            _easyfarms_agent.endpoints["crop"], 
+            data=data
+        )
+        
+        if isinstance(response, dict):
+            response['input_parameters'] = data
+            if 'mode' not in response:
+                response['mode'] = 'crop_recommendation'
+        
+        logger.info(f"Crop recommendation response: {response}")
+        return response
+        
+    except Exception as e:
+        error_result = {
+            "error": str(e),
+            "status": "error", 
+            "mode": "crop_recommendation"
+        }
+        logger.error(f"Crop recommendation failed: {e}")
+        return error_result
+
+def get_fertilizer_recommendation(
+    crop: str,
+    soil: str,
+    temperature: float,
+    humidity: float,
+    moisture: float,
+    N: int,
+    P: int,
+    K: int
+) -> Dict[str, Any]:
+    try:
+        soil_code = _easyfarms_agent.soil_mapping.get(soil.lower(), soil)
+        crop_code = _easyfarms_agent.fertilizer_crop_mapping.get(crop.lower(), crop)
+        
+        data = {
+            "temperature": temperature,
+            "humidity": humidity,
+            "moisture": moisture,
+            "N": N, "P": P, "K": K,
+            "soil": soil_code,
+            "crop": crop_code
+        }
+        
+        response = _easyfarms_agent._make_request_with_retry(
+            "POST",
+            _easyfarms_agent.endpoints["fertilizer"],
+            data=data
+        )
+        
+        if isinstance(response, dict):
+            response['input_parameters'] = {
+                **data,
+                "original_soil": soil,
+                "original_crop": crop
+            }
+            if 'mode' not in response:
+                response['mode'] = 'fertilizer_recommendation'
+        
+        logger.info(f"Fertilizer recommendation response: {response}")
+        return response
+        
+    except Exception as e:
+        error_result = {
+            "status": "error",
+            "error": str(e),
+            "mode": "fertilizer_recommendation"
+        }
+        logger.error(f"Fertilizer recommendation failed: {e}")
+        return error_result
+
+def detect_plant_disease(
+    crop: str,
+    image_path: str, # Can now be a URL or local path
+    language: str = "en"
+) -> Dict[str, Any]:
+    """
+    Detect plant diseases from an image URL or local path.
+    """
+    temp_image_path = None
+    try:
+        # Check if the image_path is a URL
+        if image_path.startswith(('http://', 'https://')):
+            logger.info(f"Downloading image from URL: {image_path}")
+            response = requests.get(image_path, stream=True, timeout=30)
+            response.raise_for_status()
+
+            # Create a temporary file to store the downloaded image
+            with tempfile.NamedTemporaryFile(delete=False, suffix=".jpg") as temp_file:
+                for chunk in response.iter_content(chunk_size=8192):
+                    temp_file.write(chunk)
+                temp_image_path = temp_file.name
+            
+            # The actual path to use is now the temporary file's path
+            path_to_process = temp_image_path
+        else:
+            # If not a URL, assume it's a local file path
+            path_to_process = image_path
+
+        # Check if the final file path exists
+        if not os.path.exists(path_to_process):
+            return {
+                "error": f"Image file not found at path: {path_to_process}",
+                "status": "error", "mode": "disease_detection"
+            }
+
+        crop_key = _easyfarms_agent.disease_crop_mapping.get(crop.lower(), crop.lower())
+        
+        headers = { 'accept': '*/*' }
+        
+        with open(path_to_process, "rb") as f:
+            files = { 'image': ('blob', f, 'image/jpeg') }
+            data = { 'crop': crop_key, 'language': language }
+            
+            response = _easyfarms_agent.session.post(
+                _easyfarms_agent.endpoints["disease"],
+                files=files, data=data, headers=headers,
+                timeout=_easyfarms_agent.timeout
+            )
+            response.raise_for_status()
+
+        result = response.json()
+        result.update({ "status": "success", "mode": "disease_detection" })
+        return result
+        
+    except Exception as e:
+        logger.error(f"Disease detection failed: {e}")
+        return { "error": str(e), "status": "error", "mode": "disease_detection" }
+    finally:
+        # Clean up the temporary file if it was created
+        if temp_image_path and os.path.exists(temp_image_path):
+            try:
+                os.remove(temp_image_path)
+                logger.info(f"Removed temporary image file: {temp_image_path}")
+            except OSError:
+                logger.warning(f"Failed to remove temporary file: {temp_image_path}")
+
+def get_supported_options(mode: str) -> Dict[str, Any]:
+    try:
+        result = {"status": "success", "mode": "supported_options"}
+        
+        if mode == "fertilizer_crops":
+            result["fertilizer_crops"] = list(_easyfarms_agent.fertilizer_crop_mapping.keys())
+        elif mode == "disease_crops":
+            result["disease_crops"] = list(_easyfarms_agent.disease_crop_mapping.keys())
+        elif mode == "soil_types":
+            result["soil_types"] = list(_easyfarms_agent.soil_mapping.keys())
+        elif mode == "all":
+            result.update({
+                "fertilizer_crops": list(_easyfarms_agent.fertilizer_crop_mapping.keys()),
+                "disease_crops": list(_easyfarms_agent.disease_crop_mapping.keys()),
+                "soil_types": list(_easyfarms_agent.soil_mapping.keys())
+            })
+        else:
+            return {
+                "error": f"Invalid mode: {mode}. Use 'fertilizer_crops', 'disease_crops', 'soil_types', or 'all'",
+                "status": "error"
+            }
+        
+        return result
+        
+    except Exception as e:
+        return {
+            "error": str(e),
+            "status": "error",
+            "mode": "supported_options"
+        }
 
 # =============================================================================
-# FUNCTION DEFINITIONS FOR AI AGENTS
+# ENHANCED FUNCTION SCHEMAS WITH MARKET DATA
 # =============================================================================
 
-# Function schemas for AI agent function calling
 EASYFARMS_FUNCTION_SCHEMAS = [
     {
         "name": "get_crop_recommendation",
@@ -286,7 +894,7 @@ EASYFARMS_FUNCTION_SCHEMAS = [
                 },
                 "image_path": {
                     "type": "string",
-                    "description": "Path to the plant/leaf image file"
+                    "description": "Path to the plant/leaf image file or image URL"
                 },
                 "language": {
                     "type": "string",
@@ -298,6 +906,94 @@ EASYFARMS_FUNCTION_SCHEMAS = [
             "required": ["crop", "image_path"]
         }
     },
+    {
+        "name": "get_market_prices",
+        "description": "Get current market prices for agricultural commodities from Indian mandis (markets). Returns price data with statistics.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "commodity": {
+                    "type": "string",
+                    "description": "Name of the commodity (e.g., 'Tomato', 'Wheat', 'Rice')"
+                },
+                "state": {
+                    "type": "string",
+                    "description": "State name (e.g., 'Gujarat', 'Maharashtra')"
+                },
+                "district": {
+                    "type": "string",
+                    "description": "District name"
+                },
+                "market": {
+                    "type": "string",
+                    "description": "Market/mandi name"
+                },
+                "limit": {
+                    "type": "integer",
+                    "description": "Number of records to fetch (default: 25, max: 100)",
+                    "minimum": 1,
+                    "maximum": 100,
+                    "default": 25
+                }
+            }
+        }
+    },
+    {
+        "name": "get_commodity_list",
+        "description": "Get list of available agricultural commodities with their varieties in the market data.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "state": {
+                    "type": "string",
+                    "description": "Optional state filter to get commodities specific to a state"
+                },
+                "limit": {
+                    "type": "integer",
+                    "description": "Number of records to analyze (default: 100)",
+                    "minimum": 1,
+                    "maximum": 500,
+                    "default": 100
+                }
+            }
+        }
+    },
+    {
+        "name": "get_market_locations",
+        "description": "Get hierarchical list of market locations organized by states, districts, and markets.",
+        "parameters": {
+            "type": "object",
+            "properties": {}
+        }
+    },
+    {
+        "name": "compare_commodity_prices",
+        "description": "Compare prices of a commodity across different states or markets to find the best deals.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "commodity": {
+                    "type": "string",
+                    "description": "Name of the commodity to compare"
+                },
+                "states": {
+                    "type": "array",
+                    "items": {
+                        "type": "string"
+                    },
+                    "description": "List of states to compare (optional, if not provided compares all)"
+                },
+                "limit": {
+                    "type": "integer",
+                    "description": "Number of records per state (default: 50)",
+                    "minimum": 1,
+                    "maximum": 100,
+                    "default": 50
+                }
+            },
+            "required": ["commodity"]
+        }
+    },
     {
         "name": "get_supported_options",
         "description": "Get lists of supported crops and soil types for different analysis modes. Useful for showing available options to users.",
@@ -315,276 +1011,19 @@ EASYFARMS_FUNCTION_SCHEMAS = [
     }
 ]
 
-# =============================================================================
-# FUNCTION IMPLEMENTATIONS
-# =============================================================================
-
-def get_crop_recommendation(
-    N: int,
-    P: int, 
-    K: int,
-    temperature: float,
-    humidity: float,
-    ph: float = None,
-    rainfall: float = 100
-) -> Dict[str, Any]:
-    try:
-        data = {
-            "N": N, "P": P, "K": K,
-            "temperature": temperature,
-            "humidity": humidity,
-            "ph": ph if ph is not None else 6.5,
-            "rainfall": rainfall
-        }
-        
-        # The response will be parsed by _make_request_with_retry
-        response = _easyfarms_agent._make_request_with_retry(
-            "POST", 
-            _easyfarms_agent.endpoints["crop"], 
-            data=data
-        )
-        
-        # Add input parameters to the response
-        if isinstance(response, dict):
-            response['input_parameters'] = data
-            if 'mode' not in response:
-                response['mode'] = 'crop_recommendation'
-        
-        logger.info(f"Crop recommendation response: {response}")
-        return response
-        
-    except Exception as e:
-        error_result = {
-            "error": str(e),
-            "status": "error", 
-            "mode": "crop_recommendation"
-        }
-        logger.error(f"Crop recommendation failed: {e}")
-        return error_result
-
-
-def get_fertilizer_recommendation(
-    crop: str,
-    soil: str,
-    temperature: float,
-    humidity: float,
-    moisture: float,
-    N: int,
-    P: int,
-    K: int
-) -> Dict[str, Any]:
-    try:
-        # Map soil and crop to codes
-        soil_code = _easyfarms_agent.soil_mapping.get(soil.lower(), soil)
-        crop_code = _easyfarms_agent.fertilizer_crop_mapping.get(crop.lower(), crop)
-        
-        data = {
-            "temperature": temperature,
-            "humidity": humidity,
-            "moisture": moisture,
-            "N": N, "P": P, "K": K,
-            "soil": soil_code,
-            "crop": crop_code
-        }
-        
-        # The response will be parsed by _make_request_with_retry
-        response = _easyfarms_agent._make_request_with_retry(
-            "POST",
-            _easyfarms_agent.endpoints["fertilizer"],
-            data=data
-        )
-        
-        # Add input parameters to the response
-        if isinstance(response, dict):
-            response['input_parameters'] = {
-                **data,
-                "original_soil": soil,
-                "original_crop": crop
-            }
-            if 'mode' not in response:
-                response['mode'] = 'fertilizer_recommendation'
-        
-        logger.info(f"Fertilizer recommendation response: {response}")
-        return response
-        
-    except Exception as e:
-        error_result = {
-            "status": "error",
-            "error": str(e),
-            "mode": "fertilizer_recommendation"
-        }
-        logger.error(f"Fertilizer recommendation failed: {e}")
-        return error_result
-
-def detect_plant_disease(
-    crop: str,
-    image_path: str,
-    language: str = "en"
-) -> Dict[str, Any]:
-    """
-    Detect plant diseases from an image using the exact API format from curl.
-    
-    Args:
-        crop: Type of crop/plant in the image
-        image_path: Path to the plant/leaf image file
-        language: Response language code (default: 'en')
-    
-    Returns:
-        Dictionary with disease detection results and metadata
-    """
-    try:
-        # Map crop to disease API format
-        crop_key = _easyfarms_agent.disease_crop_mapping.get(crop.lower(), crop.lower())
-        
-        # Check if file exists
-        import os
-        if not os.path.exists(image_path):
-            return {
-                "error": f"Image file not found: {image_path}",
-                "status": "error",
-                "mode": "disease_detection"
-            }
-        
-        # Prepare headers exactly like the curl command
-        headers = {
-            'accept': '*/*',
-            'accept-language': 'en-IN,en-US;q=0.9,en;q=0.8,hi;q=0.7',
-            'origin': 'https://app.easyfarms.in',
-            'referer': 'https://app.easyfarms.in/',
-            'sec-ch-ua': '"Chromium";v="140", "Not=A?Brand";v="24", "Google Chrome";v="140"',
-            'sec-ch-ua-mobile': '?1',
-            'sec-ch-ua-platform': '"Android"',
-            'sec-fetch-dest': 'empty',
-            'sec-fetch-mode': 'cors',
-            'sec-fetch-site': 'cross-site',
-            'user-agent': 'Mozilla/5.0 (Linux; Android 6.0; Nexus 5 Build/MRA58N) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/140.0.0.0 Mobile Safari/537.36'
-        }
-        
-        # Make request with image using the exact format
-        with open(image_path, "rb") as f:
-            files = {
-                'image': ('blob', f, 'image/jpeg')
-            }
-            data = {
-                'crop': crop_key,
-                'language': language
-            }
-            
-            # Use direct requests instead of the agent's retry method for this specific API
-            response = _easyfarms_agent.session.post(
-                _easyfarms_agent.endpoints["disease"],
-                files=files,
-                data=data,
-                headers=headers,
-                timeout=_easyfarms_agent.timeout
-            )
-            response.raise_for_status()
-        
-        # Try to parse JSON response
-        try:
-            result = response.json()
-        except ValueError:
-            # If JSON parsing fails, return the raw text
-            result = {
-                "raw_response": response.text,
-                "content_type": response.headers.get('content-type', ''),
-                "status_code": response.status_code
-            }
-        
-        # Add metadata to result
-        if isinstance(result, dict):
-            result.update({
-                "status": "success",
-                "mode": "disease_detection",
-                "input_parameters": {
-                    "crop": crop,
-                    "crop_key": crop_key,
-                    "language": language,
-                    "image_path": image_path
-                }
-            })
-        else:
-            # If result is not a dict, wrap it
-            result = {
-                "detection_result": result,
-                "status": "success",
-                "mode": "disease_detection",
-                "input_parameters": {
-                    "crop": crop,
-                    "crop_key": crop_key,
-                    "language": language,
-                    "image_path": image_path
-                }
-            }
-        
-        logger.info(f"Disease detection successful for {crop}")
-        return result
-        
-    except Exception as e:
-        error_result = {
-            "error": str(e),
-            "status": "error",
-            "mode": "disease_detection",
-            "input_parameters": {
-                "crop": crop,
-                "language": language,
-                "image_path": image_path
-            }
-        }
-        logger.error(f"Disease detection failed: {e}")
-        return error_result
-
-
-def get_supported_options(mode: str) -> Dict[str, Any]:
-    """
-    Get lists of supported options for different modes.
-    
-    Args:
-        mode: Mode to get options for ("fertilizer_crops", "disease_crops", "soil_types", "all")
-    
-    Returns:
-        Dictionary with supported options
-    """
-    try:
-        result = {"status": "success", "mode": "supported_options"}
-        
-        if mode == "fertilizer_crops":
-            result["fertilizer_crops"] = list(_easyfarms_agent.fertilizer_crop_mapping.keys())
-        elif mode == "disease_crops":
-            result["disease_crops"] = list(_easyfarms_agent.disease_crop_mapping.keys())
-        elif mode == "soil_types":
-            result["soil_types"] = list(_easyfarms_agent.soil_mapping.keys())
-        elif mode == "all":
-            result.update({
-                "fertilizer_crops": list(_easyfarms_agent.fertilizer_crop_mapping.keys()),
-                "disease_crops": list(_easyfarms_agent.disease_crop_mapping.keys()),
-                "soil_types": list(_easyfarms_agent.soil_mapping.keys())
-            })
-        else:
-            return {
-                "error": f"Invalid mode: {mode}. Use 'fertilizer_crops', 'disease_crops', 'soil_types', or 'all'",
-                "status": "error"
-            }
-        
-        return result
-        
-    except Exception as e:
-        return {
-            "error": str(e),
-            "status": "error",
-            "mode": "supported_options"
-        }
-
 # =============================================================================
 # FUNCTION MAPPING FOR AI AGENTS
 # =============================================================================
 
-# Map function names to implementations
 EASYFARMS_FUNCTIONS = {
     "get_crop_recommendation": get_crop_recommendation,
     "get_fertilizer_recommendation": get_fertilizer_recommendation, 
     "detect_plant_disease": detect_plant_disease,
-    "get_supported_options": get_supported_options
+    "get_supported_options": get_supported_options,
+    "get_market_prices": get_market_prices,
+    "get_commodity_list": get_commodity_list,
+    "get_market_locations": get_market_locations,
+    "compare_commodity_prices": compare_commodity_prices
 }
 
 # =============================================================================
@@ -634,18 +1073,45 @@ def get_function_names() -> List[str]:
 # =============================================================================
 
 if __name__ == "__main__":
-    # Example of how to use in an AI agent
+    print("=== Enhanced EasyFarms Agent with Market Data ===\n")
+    
+    print("Available Functions:")
+    for name in get_function_names():
+        print(f"  - {name}")
+    print()
+    
+    # Example 1: Get market prices
+    print("1. Getting tomato prices in Gujarat:")
+    market_result = execute_easyfarms_function(
+        "get_market_prices",
+        commodity="Tomato",
+        state="Gujarat",
+        limit=10
+    )
+    print(json.dumps(market_result, indent=2))
+    print()
     
-    print("=== EasyFarms Function Schemas ===")
-    schemas = get_function_schemas()
-    for schema in schemas:
-        print(f"Function: {schema['name']}")
-        print(f"Description: {schema['description']}")
-        print()
+    # Example 2: Compare commodity prices
+    print("2. Comparing wheat prices across states:")
+    comparison_result = execute_easyfarms_function(
+        "compare_commodity_prices",
+        commodity="Wheat",
+        states=["Punjab", "Haryana", "Uttar Pradesh"]
+    )
+    print(json.dumps(comparison_result, indent=2))
+    print()
     
-    print("=== Example Function Calls ===")
+    # Example 3: Get commodity list
+    print("3. Getting available commodities:")
+    commodity_result = execute_easyfarms_function(
+        "get_commodity_list",
+        limit=20
+    )
+    print(f"Total commodities: {commodity_result.get('total_commodities', 0)}")
+    print()
     
-    # Crop recommendation
+    # Example 4: Crop recommendation (existing function)
+    print("4. Getting crop recommendation:")
     crop_result = execute_easyfarms_function(
         "get_crop_recommendation",
         N=90, P=42, K=43,
@@ -654,32 +1120,4 @@ if __name__ == "__main__":
         ph=6.5,
         rainfall=202.9
     )
-    print("Crop recommendation:", json.dumps(crop_result, indent=2))
-    
-    # Get supported options
-    options_result = execute_easyfarms_function(
-        "get_supported_options",
-        mode="all"
-    )
-    print("Supported options:", json.dumps(options_result, indent=2))
-    
-    # Fertilizer recommendation
-    fertilizer_result = execute_easyfarms_function(
-        "get_fertilizer_recommendation",
-        crop="paddy",
-        soil="loamy", 
-        temperature=26.0,
-        humidity=52.0,
-        moisture=38.0,
-        N=37, P=0, K=0
-    )
-    print("Fertilizer recommendation:", json.dumps(fertilizer_result, indent=2))
-    
-    # Test disease detection (if you have an image file)
-    disease_result = execute_easyfarms_function(
-        "detect_plant_disease",
-        crop="potato",
-        image_path="potato-diseases.jpg",
-        language="en"
-    )
-    print("Disease detection:", json.dumps(disease_result, indent=2))
+    print(json.dumps(crop_result, indent=2))

functions_calling.py

@@ -0,0 +1,61 @@
+WEATHER_FUNCTIONS = [
+    {
+        "type": "function",
+        "function": {
+            "name": "get_weather_alerts",
+            "description": "Get weather alerts for one or more locations in India. Can search by city, state, district, or region name.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "locations": {
+                        "type": "array",
+                        "items": {
+                            "type": "string"
+                        },
+                        "description": "List of locations to search for (up to 5). Can be city names, state names, districts, etc.",
+                        "maxItems": 5,
+                        "minItems": 1
+                    },
+                    "include_details": {
+                        "type": "boolean",
+                        "description": "Whether to include detailed alert information like warning messages and coordinates",
+                        "default": True
+                    }
+                },
+                "required": ["locations"]
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "get_alert_summary",
+            "description": "Get a summary of all current weather alerts by severity level",
+            "parameters": {
+                "type": "object",
+                "properties": {},
+                "required": []
+            }
+        }
+    },
+    {
+        "type": "function",
+        "function": {
+            "name": "get_available_locations",
+            "description": "Get a list of all locations that currently have weather alerts",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "limit": {
+                        "type": "integer",
+                        "description": "Maximum number of locations to return",
+                        "default": 50,
+                        "minimum": 1,
+                        "maximum": 200
+                    }
+                },
+                "required": []
+            }
+        }
+    }
+]

server.py

@@ -0,0 +1,139 @@
+# flask_app.py
+
+from flask import Flask, request, jsonify, render_template
+from app import EasyFarmsAssistant
+from conversation_manager import ConversationManager # Make sure this import is present
+import logging
+import uuid
+import os
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+# Initialize the Flask application
+app = Flask(__name__)
+
+# --- Initialize Core Services ---
+# This setup assumes your .env file is correctly configured with Supabase credentials.
+try:
+    conv_manager = ConversationManager()
+    assistant = EasyFarmsAssistant(manager=conv_manager)
+    logger.info("EasyFarmsAssistant and ConversationManager initialized successfully.")
+except Exception as e:
+    logger.error(f"FATAL: Could not initialize services. Error: {e}")
+    assistant = None
+    conv_manager = None
+
+# --- Frontend Serving Route ---
+@app.route('/')
+def index():
+    """Serves the main chat application page (index.html)."""
+    return render_template('index.html')
+
+# --- API Endpoints ---
+
+@app.route('/config', methods=['GET'])
+def get_config():
+    """Provides public configuration keys to the frontend."""
+    return jsonify({
+        'imgbb_api_key': os.getenv('IMGBB_API_KEY')
+    })
+
+@app.route('/chat', methods=['POST'])
+def chat():
+    """Handles incoming user messages and returns the assistant's response."""
+    if not assistant:
+        return jsonify({"error": "Assistant is not available due to an initialization error."}), 503
+
+    # The request is multipart/form-data to handle potential image uploads
+    data = request.form
+    user_message = data.get('message')
+    session_id = data.get('session_id')
+    image_url = data.get('image_url') # The permanent URL from ImgBB
+
+    # A message must contain either text or an image
+    if not user_message and not image_url:
+        return jsonify({"error": "Cannot process an empty message."}), 400
+    
+    # If no session_id is provided by the client, it's a new conversation
+    if not session_id or session_id == 'null' or session_id == 'undefined':
+        session_id = str(uuid.uuid4())
+        logger.info(f"No session_id provided. Creating new session: {session_id}")
+    
+    # Call the assistant's core logic, now passing the image_url separately
+    response_content = assistant.process_query(
+        user_message=user_message or "",  # Ensure user_message is a string
+        session_id=session_id,
+        image_url=image_url
+    )
+    
+    return jsonify({
+        "response": response_content,
+        "session_id": session_id
+    })
+
+@app.route('/history/sessions', methods=['GET'])
+def get_sessions():
+    """Fetches a list of all conversation sessions for the sidebar."""
+    if not conv_manager:
+        return jsonify({"error": "Conversation manager not available"}), 503
+    try:
+        # Fetch session_id and the full history to generate a title
+        all_conversations = conv_manager.supabase.table('conversations').select('session_id, history').execute()
+        
+        sessions = []
+        for conv in all_conversations.data:
+            title = "New Chat" # Default title
+            # Generate a title from the first user message in the history
+            if conv.get('history') and len(conv['history']) > 0:
+                first_message_content = conv['history'][0].get('content')
+                if first_message_content:
+                    # Truncate for display
+                    title = first_message_content[:35] + '...' if len(first_message_content) > 35 else first_message_content
+                else: # If the first message was only an image
+                    title = "Image Query"
+
+            sessions.append({
+                "session_id": conv.get('session_id'),
+                "title": title
+            })
+        
+        return jsonify(sessions)
+    except Exception as e:
+        logger.error(f"Error fetching sessions from Supabase: {e}")
+        return jsonify({"error": "Could not fetch conversation sessions"}), 500
+
+@app.route('/history/messages/<session_id>', methods=['GET'])
+def get_messages(session_id):
+    """Fetches the full, structured message history for a given session_id."""
+    if not conv_manager:
+        return jsonify({"error": "Conversation manager not available"}), 503
+    try:
+        history = conv_manager.get_history(session_id)
+        return jsonify(history)
+    except Exception as e:
+        logger.error(f"Error fetching messages for session {session_id}: {e}")
+        return jsonify({"error": "Could not fetch message history"}), 500
+
+@app.route('/clear', methods=['POST'])
+def clear_history():
+    """Deletes a conversation history from the database."""
+    if not assistant:
+        return jsonify({"error": "Assistant is not available."}), 503
+    
+    data = request.get_json()
+    session_id = data.get('session_id')
+
+    if not session_id:
+        return jsonify({"error": "Missing 'session_id' in request body"}), 400
+
+    if assistant.clear_history(session_id):
+        return jsonify({"status": "success", "message": f"History for session {session_id} was cleared."})
+    else:
+        return jsonify({"error": "Failed to clear history."}), 500
+
+# --- Main Execution ---
+if __name__ == '__main__':
+    # Set debug=False for production
+    app.run(debug=True, port=5000)

static/script.js

@@ -0,0 +1,233 @@
+document.addEventListener('DOMContentLoaded', () => {
+    
+    // --- DOM Elements ---
+    const chatArea = document.getElementById('chat-area');
+    const closeSidebarBtn = document.getElementById('close-sidebar-btn');
+    const messageInput = document.getElementById('message-input');
+    const sendBtn = document.getElementById('send-btn');
+    const newChatBtn = document.getElementById('new-chat-btn');
+    const chatMessages = document.getElementById('chat-messages');
+    const chatHistoryList = document.getElementById('chat-history-list');
+    const menuToggle = document.getElementById('menu-toggle');
+    const appContainer = document.getElementById('app-container');
+    const chatTitle = document.getElementById('chat-title');
+    const imageUploadBtn = document.getElementById('image-upload-btn');
+    const imageUploadInput = document.getElementById('image-upload-input');
+    const imagePreviewContainer = document.getElementById('image-preview-container');
+    const imagePreview = document.getElementById('image-preview');
+    const removeImageBtn = document.getElementById('remove-image-btn');
+
+    // --- State ---
+    let currentSessionId = null;
+    let conversationsCache = {};
+    let selectedImageFile = null;
+    let imgbbApiKey = '';
+
+    // --- Initialization ---
+    const init = async () => {
+        if (!messageInput || !sendBtn || !imageUploadBtn || !imagePreviewContainer) {
+            console.error("Critical UI elements not found. Check HTML IDs.");
+            return;
+        }
+
+        await fetchConfig();
+        loadCache();
+        await renderChatHistoryFromAPI();
+
+        // Event Listeners
+        sendBtn.addEventListener('click', sendMessage);
+        messageInput.addEventListener('keydown', e => { if (e.key === 'Enter' && !e.shiftKey) { e.preventDefault(); sendMessage(); } });
+        
+        imageUploadBtn.addEventListener('click', () => imageUploadInput.click());
+        imageUploadInput.addEventListener('change', handleImageSelect);
+        removeImageBtn.addEventListener('click', removeSelectedImage);
+
+        // Sidebar Listeners
+        newChatBtn.addEventListener('click', () => { startNewChat(); closeSidebar(); });
+        menuToggle.addEventListener('click', (event) => {
+            event.stopPropagation();
+            appContainer.classList.toggle('sidebar-visible');
+        });
+        closeSidebarBtn.addEventListener('click', (event) => {
+            event.stopPropagation();
+            closeSidebar();
+        });
+        chatArea.addEventListener('click', () => {
+            if (appContainer.classList.contains('sidebar-visible')) {
+                closeSidebar();
+            }
+        });
+    };
+
+    const fetchConfig = async () => {
+        try {
+            const response = await fetch('/config');
+            const config = await response.json();
+            imgbbApiKey = config.imgbb_api_key;
+            if (!imgbbApiKey) { console.error("ImgBB API Key is missing."); }
+        } catch (error) { console.error('Failed to fetch config:', error); }
+    };
+
+    // --- Core Chat Functions ---
+    const sendMessage = async () => {
+        const messageText = messageInput.value.trim();
+        if (!messageText && !selectedImageFile) return;
+        displayMessage({ role: 'user', content: messageText, imageUrl: selectedImageFile });
+        const loadingIndicator = displayMessage({ role: 'assistant', content: 'Thinking...', isLoading: true });
+        try {
+            let permanentImageUrl = null;
+            if (selectedImageFile) { permanentImageUrl = await uploadImageToImgBB(selectedImageFile); }
+            const formData = new FormData();
+            formData.append('message', messageText);
+            formData.append('session_id', currentSessionId);
+            if (permanentImageUrl) { formData.append('image_url', permanentImageUrl); }
+            const response = await fetch('/chat', { method: 'POST', body: formData });
+            if (!response.ok) throw new Error('Network response was not ok.');
+            const data = await response.json();
+            chatMessages.removeChild(loadingIndicator);
+            displayMessage({ role: 'assistant', content: data.response });
+            updateCache(data.session_id, { content: messageText, imageUrl: permanentImageUrl }, { content: data.response });
+        } catch (error) {
+            console.error('Error sending message:', error);
+            loadingIndicator.innerHTML = marked.parse("Sorry, something went wrong.");
+            loadingIndicator.classList.remove('loading');
+        } finally {
+            messageInput.value = ''; messageInput.style.height = 'auto'; removeSelectedImage();
+        }
+    };
+
+    const uploadImageToImgBB = async (imageFile) => {
+        if (!imgbbApiKey) throw new Error("ImgBB API Key not configured.");
+        const formData = new FormData();
+        formData.append('image', imageFile);
+        formData.append('key', imgbbApiKey);
+        const response = await fetch('https://api.imgbb.com/1/upload', { method: 'POST', body: formData });
+        const result = await response.json();
+        if (result.success) { return result.data.url; }
+        else { throw new Error(result.error.message || 'Image upload failed.'); }
+    };
+
+    // --- Caching and State Management ---
+    const startNewChat = () => {
+        currentSessionId = null;
+        chatMessages.innerHTML = `<div class="welcome-message"><h1>EasyFarms Assistant</h1></div>`;
+        chatTitle.textContent = "New Chat";
+        updateActiveChatItem();
+    };
+
+    const switchChat = async (sessionId) => {
+        currentSessionId = sessionId;
+        chatMessages.innerHTML = '';
+        if (conversationsCache[sessionId] && conversationsCache[sessionId].messages) {
+            conversationsCache[sessionId].messages.forEach(displayMessage);
+        } else {
+            const loading = displayMessage({ role: 'assistant', content: 'Loading chat history...', isLoading: true });
+            try {
+                const response = await fetch(`/history/messages/${sessionId}`);
+                const messages = await response.json();
+                if (!conversationsCache[sessionId]) conversationsCache[sessionId] = {};
+                conversationsCache[sessionId].messages = messages;
+                saveCache();
+                chatMessages.removeChild(loading);
+                messages.forEach(displayMessage);
+            } catch (error) {
+                loading.innerHTML = marked.parse("Failed to load chat history.");
+            }
+        }
+        chatTitle.textContent = conversationsCache[sessionId]?.title || "Chat";
+        updateActiveChatItem();
+        closeSidebar();
+    };
+
+    const updateCache = (sessionId, userTurn, assistantTurn) => {
+        const isNewChat = !currentSessionId;
+        currentSessionId = sessionId;
+        if (isNewChat) {
+            const title = (userTurn.content || "Image Query").substring(0, 30) + '...';
+            conversationsCache[sessionId] = { title, messages: [] };
+            const item = document.createElement('div');
+            item.className = 'chat-history-item';
+            item.textContent = title;
+            item.dataset.sessionId = sessionId;
+            item.addEventListener('click', () => switchChat(sessionId));
+            chatHistoryList.prepend(item);
+        }
+        const userMessage = { role: 'user', content: userTurn.content };
+        if (userTurn.imageUrl) userMessage.imageUrl = userTurn.imageUrl;
+        const assistantMessage = { role: 'assistant', content: assistantTurn.content };
+        conversationsCache[sessionId].messages.push(userMessage, assistantMessage);
+        saveCache();
+        updateActiveChatItem();
+    };
+
+    const displayMessage = (message) => {
+        const { role, content, imageUrl, isLoading } = message;
+        const sender = role || message.sender;
+        const messageDiv = document.createElement('div');
+        messageDiv.classList.add('message', `${sender}-message`);
+        let htmlContent = '';
+        const imageSrc = (typeof imageUrl === 'object' && imageUrl instanceof File) ? URL.createObjectURL(imageUrl) : imageUrl;
+        if (imageSrc) { htmlContent += `<img src="${imageSrc}" alt="User upload" class="user-upload">`; }
+        if (content) { htmlContent += marked.parse(content); }
+        messageDiv.innerHTML = htmlContent || (isLoading ? '...' : '');
+        if (isLoading) messageDiv.classList.add('loading');
+        chatMessages.appendChild(messageDiv);
+        chatMessages.scrollTop = chatMessages.scrollHeight;
+        return messageDiv;
+    };
+
+    // --- Image Preview Handling ---
+    const handleImageSelect = (event) => {
+        const file = event.target.files[0];
+        if (file) {
+            selectedImageFile = file;
+            imagePreview.src = URL.createObjectURL(file);
+            imagePreviewContainer.style.display = 'block';
+        }
+    };
+
+    const removeSelectedImage = () => {
+        selectedImageFile = null;
+        imageUploadInput.value = '';
+        imagePreviewContainer.style.display = 'none';
+        imagePreview.src = '#';
+    };
+
+    // --- LocalStorage Cache & Sidebar Rendering ---
+    const saveCache = () => localStorage.setItem('easyfarms_cache', JSON.stringify(conversationsCache));
+    const loadCache = () => {
+        const saved = localStorage.getItem('easyfarms_cache');
+        if (saved) conversationsCache = JSON.parse(saved);
+    };
+
+    const renderChatHistoryFromAPI = async () => {
+        try {
+            const response = await fetch('/history/sessions');
+            const sessions = await response.json();
+            chatHistoryList.innerHTML = '';
+            sessions.reverse().forEach(session => {
+                if (!conversationsCache[session.session_id]) conversationsCache[session.session_id] = {};
+                conversationsCache[session.session_id].title = session.title;
+                const item = document.createElement('div');
+                item.className = 'chat-history-item';
+                item.textContent = session.title;
+                item.dataset.sessionId = session.session_id;
+                item.addEventListener('click', () => switchChat(session.session_id));
+                chatHistoryList.appendChild(item);
+            });
+            saveCache();
+            updateActiveChatItem();
+        } catch (error) { console.error("Failed to render chat history from API:", error); }
+    };
+
+    const updateActiveChatItem = () => {
+        document.querySelectorAll('.chat-history-item').forEach(item => {
+            item.classList.toggle('active', item.dataset.sessionId === currentSessionId);
+        });
+    };
+
+    const closeSidebar = () => appContainer.classList.remove('sidebar-visible');
+
+    // --- Start the Application ---
+    init();
+});

static/style.css

@@ -0,0 +1,164 @@
+:root {
+    --bg-color: #131314;
+    --sidebar-color: #1e1f20;
+    --chat-area-color: #131314;
+    --user-msg-color: #383a3f;
+    --assistant-msg-color: #252629;
+    --text-color: #e3e3e3;
+    --border-color: #333;
+    --accent-color: #4CAF50;
+    --font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif;
+}
+
+* { box-sizing: border-box; margin: 0; padding: 0; }
+
+body {
+    font-family: var(--font-family);
+    background-color: var(--bg-color);
+    color: var(--text-color);
+    display: flex;
+    height: 100vh;
+    overflow: hidden;
+}
+
+.app-container {
+    display: flex;
+    width: 100%;
+    height: 100%;
+    position: relative;
+}
+
+/* Sidebar (hidden on mobile by default) */
+.sidebar {
+    position: absolute;
+    top: 0;
+    left: 0;
+    bottom: 0;
+    width: 260px;
+    background-color: var(--sidebar-color);
+    display: flex;
+    flex-direction: column;
+    padding: 10px;
+    transform: translateX(-100%);
+    transition: transform 0.3s ease-in-out;
+    z-index: 101; /* Must be on top */
+}
+.app-container.sidebar-visible .sidebar {
+    transform: translateX(0);
+}
+.sidebar-header {
+    display: flex;
+    gap: 10px;
+    align-items: center;
+}
+.sidebar-button {
+    flex-grow: 1; /* Allow button to take available space */
+    padding: 10px 15px;
+    background-color: transparent;
+    border: 1px solid var(--border-color);
+    border-radius: 8px;
+    color: var(--text-color);
+    cursor: pointer;
+    font-size: 1rem;
+    display: flex;
+    align-items: center;
+    gap: 10px;
+    transition: background-color 0.2s;
+}
+.sidebar-button:hover { background-color: var(--user-msg-color); }
+.chat-history { flex-grow: 1; overflow-y: auto; margin-top: 20px; }
+
+.chat-history-item {
+    padding: 10px 15px;
+    margin-bottom: 5px;
+    border-radius: 6px;
+    cursor: pointer;
+    white-space: nowrap;
+    overflow: hidden;
+    text-overflow: ellipsis;
+    transition: background-color 0.2s;
+}
+.chat-history-item:hover { background-color: var(--user-msg-color); }
+.chat-history-item.active { background-color: var(--user-msg-color); font-weight: bold; }
+
+.close-sidebar-btn {
+    background: none;
+    border: none;
+    color: #999;
+    cursor: pointer;
+    display: none; /* Hidden by default */
+    padding: 5px;
+}
+.app-container.sidebar-visible .close-sidebar-btn {
+    display: block; /* Show when sidebar is visible */
+}
+
+/* Main Chat Area */
+.chat-area {
+    width: 100%;
+    display: flex;
+    flex-direction: column;
+    background-color: var(--chat-area-color);
+    position: relative;
+    transition: filter 0.3s;
+}
+.app-container.sidebar-visible .chat-area::before {
+    content: '';
+    position: absolute;
+    top: 0;
+    left: 0;
+    right: 0;
+    bottom: 0;
+    background-color: rgba(0, 0, 0, 0.5);
+    z-index: 100;
+}
+
+.chat-header { display: flex; align-items: center; padding: 10px; border-bottom: 1px solid var(--border-color); }
+.menu-toggle { background: none; border: none; color: var(--text-color); cursor: pointer; }
+#chat-title { margin-left: 15px; font-size: 1.1rem; }
+
+.chat-messages { flex-grow: 1; overflow-y: auto; padding: 10px 20px; display: flex; flex-direction: column; }
+.welcome-message { text-align: center; margin: auto; color: #888; }
+
+.message { max-width: 90%; margin-bottom: 15px; padding: 10px 15px; border-radius: 12px; line-height: 1.6; word-wrap: break-word; }
+.message p, .message ul, .message ol { margin: 0.5em 0; }
+.message ul, .message ol { padding-left: 20px; }
+.message code { background-color: #111; padding: 2px 4px; border-radius: 4px; }
+.message pre { background-color: #111; padding: 10px; border-radius: 8px; overflow-x: auto; }
+.message img.user-upload { max-width: 150px; border-radius: 8px; margin-top: 10px; }
+
+.user-message { background-color: var(--user-msg-color); align-self: flex-end; }
+.assistant-message { background-color: var(--assistant-msg-color); align-self: flex-start; }
+.assistant-message.loading::after { content: '...'; display: inline-block; animation: blink 1s infinite; }
+@keyframes blink { 50% { opacity: 0; } }
+
+/* Chat Input */
+.chat-input-area { padding: 10px 20px; border-top: 1px solid var(--border-color); }
+.image-preview { position: relative; width: 80px; margin-bottom: 10px; }
+#image-preview { width: 100%; border-radius: 8px; }
+#remove-image-btn {
+    position: absolute; top: -5px; right: -5px;
+    background: #000; color: #fff; border: 1px solid #fff;
+    border-radius: 50%; width: 20px; height: 20px;
+    cursor: pointer; display: flex; align-items: center; justify-content: center;
+}
+
+.chat-input-wrapper { display: flex; align-items: flex-end; gap: 10px; }
+#message-input {
+    flex-grow: 1; background: var(--assistant-msg-color);
+    border: 1px solid var(--border-color); color: var(--text-color);
+    font-size: 1rem; padding: 10px; resize: none;
+    max-height: 150px; overflow-y: auto; outline: none; border-radius: 8px;
+}
+
+.input-action-btn { background: transparent; border: none; color: #888; cursor: pointer; height: 44px; width: 44px; display: flex; align-items: center; justify-content: center; }
+.send-btn { background: var(--accent-color); color: white; border-radius: 8px; }
+
+/* Desktop styles */
+@media (min-width: 768px) {
+    .chat-header { display: none; }
+    .sidebar { position: static; transform: translateX(0); border-right: 1px solid var(--border-color); }
+    .close-sidebar-btn { display: none !important; } /* Close button is never needed on desktop */
+    .app-container.sidebar-visible .chat-area::before { display: none; } /* No overlay on desktop */
+    .chat-area { width: auto; flex-grow: 1; }
+}

templates/index.html

@@ -0,0 +1,60 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>EasyFarms Assistant</title>
+    <link rel="stylesheet" href="{{ url_for('static', filename='style.css') }}">
+    <script src="https://cdn.jsdelivr.net/npm/marked/marked.min.js"></script>
+</head>
+<body>
+    <div id="app-container" class="app-container">
+        <!-- Sidebar for sessions (hidden on mobile) -->
+        <aside class="sidebar">
+            <div class="sidebar-header">
+                <button id="new-chat-btn" class="sidebar-button">
+                    <span class="icon">+</span> New Chat
+                </button>
+                <button id="close-sidebar-btn" class="close-sidebar-btn">
+                    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor" width="24" height="24">
+                        <path fill-rule="evenodd" d="M5.47 5.47a.75.75 0 011.06 0L12 10.94l5.47-5.47a.75.75 0 111.06 1.06L13.06 12l5.47 5.47a.75.75 0 11-1.06 1.06L12 13.06l-5.47 5.47a.75.75 0 01-1.06-1.06L10.94 12 5.47 6.53a.75.75 0 010-1.06z" clip-rule="evenodd" />
+                    </svg>
+                </button>
+            </div>
+            <div class="chat-history" id="chat-history-list"></div>
+        </aside>
+
+        <!-- Main chat window -->
+        <main id="chat-area" class="chat-area">
+            <header class="chat-header">
+                <button id="menu-toggle" class="menu-toggle">
+                    <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor" width="24" height="24"><path d="M3 6.75A.75.75 0 013.75 6h16.5a.75.75 0 010 1.5H3.75A.75.75 0 013 6.75zM3 12a.75.75 0 01.75-.75h16.5a.75.75 0 010 1.5H3.75A.75.75 0 013 12zm0 5.25a.75.75 0 01.75-.75h16.5a.75.75 0 010 1.5H3.75a.75.75 0 01-.75-.75z"></path></svg>
+                </button>
+                <h2 id="chat-title">New Chat</h2>
+            </header>
+            <div class="chat-messages" id="chat-messages">
+                <div class="welcome-message">
+                    <h1>EasyFarms Assistant</h1>
+                </div>
+            </div>
+            <div class="chat-input-area">
+                <div class="image-preview" id="image-preview-container" style="display: none;">
+                    <img id="image-preview" src="#" alt="Image preview"/>
+                    <button id="remove-image-btn">&times;</button>
+                </div>
+                <div class="chat-input-wrapper">
+                    <input type="file" id="image-upload-input" accept="image/*" style="display: none;">
+                    <button id="image-upload-btn" class="input-action-btn">
+                        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor" width="20" height="20"><path fill-rule="evenodd" d="M1.5 6a2.25 2.25 0 012.25-2.25h16.5A2.25 2.25 0 0122.5 6v12a2.25 2.25 0 01-2.25 2.25H3.75A2.25 2.25 0 011.5 18V6zM3 16.06V18c0 .414.336.75.75.75h16.5A.75.75 0 0021 18v-1.94l-2.69-2.689a1.5 1.5 0 00-2.12 0l-.88.879.97.97a.75.75 0 11-1.06 1.06l-5.16-5.159a1.5 1.5 0 00-2.12 0L3 16.061zm10.125-7.81a1.125 1.125 0 112.25 0 1.125 1.125 0 01-2.25 0z" clip-rule="evenodd"></path></svg>
+                    </button>
+                    <textarea id="message-input" placeholder="Ask a question..." rows="1"></textarea>
+                    <button id="send-btn" class="input-action-btn send-btn">
+                        <svg xmlns="http://www.w3.org/2000/svg" viewBox="0 0 24 24" fill="currentColor" class="send-icon"><path d="M3.478 2.405a.75.75 0 00-.926.94l2.432 7.905H13.5a.75.75 0 010 1.5H4.984l-2.432 7.905a.75.75 0 00.926.94 60.519 60.519 0 0018.445-8.986.75.75 0 000-1.218A60.517 60.517 0 003.478 2.405z"></path></svg>
+                    </button>
+                </div>
+            </div>
+        </main>
+    </div>
+    <script src="{{ url_for('static', filename='script.js') }}"></script>
+</body>
+</html>