Upload 3 files

alert.py

@@ -0,0 +1,405 @@
+# alert.py
+
+import json
+import os
+import re
+from typing import Any, Dict, List
+from weatherr import get_weather
+from dotenv import load_dotenv
+from openai import OpenAI
+import requests
+load_dotenv()
+
+
+class WeatherAlertAPI:
+    def __init__(self):
+        self.api_url = "http://sachet.ndma.gov.in/cap_public_website/FetchAllAlertDetails"
+    
+    def fetch_alerts(self) -> List[Dict[str, Any]]:
+        """Fetch all weather alerts from the NDMA API"""
+        try:
+            response = requests.get(self.api_url, timeout=30)
+            response.raise_for_status()
+            data = response.json()
+            
+            if isinstance(data, list):
+                return data
+            elif isinstance(data, dict) and "nowcastDetails" in data:
+                return data["nowcastDetails"]
+            else:
+                return []
+                
+        except Exception as e:
+            print(f"Error fetching alerts: {e}")
+            return []
+    
+    def normalize_text(self, text: str) -> str:
+        """Normalize text for better matching"""
+        return re.sub(r'\s+', ' ', text.strip().lower())
+    
+    def location_matches(self, area_description: str, search_terms: List[str]) -> bool:
+        """Check if any search terms match the area description"""
+        normalized_area = self.normalize_text(area_description)
+        for term in search_terms:
+            normalized_term = self.normalize_text(term)
+            if normalized_term in normalized_area:
+                return True
+        return False
+
+# Initialize the weather API
+weather_api = WeatherAlertAPI()
+
+# OpenAI Tool Definitions (Updated format)
+WEATHER_TOOLS = [
+    {
+        "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_weather",
+            "description": "Fetch current weather using address, coordinates, or district/state.",
+            "parameters": {
+                "type": "object",
+                "properties": {
+                    "latitude": {"type": "number", "description": "Latitude coordinate"},
+                    "longitude": {"type": "number", "description": "Longitude coordinate"},
+                    "address": {"type": "string", "description": "Full address or location name"},
+                    "district": {"type": "string", "description": "District name"},
+                    "state": {"type": "string", "description": "State name"}
+                },
+                "required": []  # none are strictly required; function will validate
+            }
+        }
+    },
+    {
+        "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": []
+            }
+        }
+    }
+]
+
+def get_current_weather(latitude: float = None, longitude: float = None, address: str = None, district: str = None, state: str = None):
+    return get_weather(latitude=latitude, longitude=longitude, address=address, district=district, state=state)
+
+# Function Implementations
+def get_weather_alerts(locations: List[str], include_details: bool = True) -> Dict[str, Any]:
+    """
+    Get weather alerts for specified locations
+    """
+    try:
+        all_alerts = weather_api.fetch_alerts()
+        
+        if not all_alerts:
+            return {
+                "status": "error",
+                "message": "No alerts found or error fetching data",
+                "data": {}
+            }
+        
+        results = {}
+        total_alerts = 0
+        
+        for location in locations:
+            search_terms = [term.strip() for term in location.split(',') if term.strip()]
+            location_alerts = []
+            
+            for alert in all_alerts:
+                area_desc = alert.get("area_description", "")
+                if weather_api.location_matches(area_desc, search_terms):
+                    if include_details:
+                        # Full alert details
+                        alert_data = {
+                            "alert_id": alert.get("identifier"),
+                            "severity": alert.get("severity"),
+                            "severity_level": alert.get("severity_level"),
+                            "severity_color": alert.get("severity_color"),
+                            "disaster_type": alert.get("disaster_type"),
+                            "area_description": alert.get("area_description"),
+                            "start_time": alert.get("effective_start_time"),
+                            "end_time": alert.get("effective_end_time"),
+                            "source": alert.get("alert_source"),
+                            "area_covered": alert.get("area_covered"),
+                            "language": alert.get("actual_lang"),
+                            "warning_message": alert.get("warning_message"),
+                            "coordinates": alert.get("centroid"),
+                            "disseminated": alert.get("disseminated")
+                        }
+                    else:
+                        # Summary only
+                        alert_data = {
+                            "alert_id": alert.get("identifier"),
+                            "severity": alert.get("severity"),
+                            "disaster_type": alert.get("disaster_type"),
+                            "area_description": alert.get("area_description"),
+                            "start_time": alert.get("effective_start_time"),
+                            "end_time": alert.get("effective_end_time")
+                        }
+                    
+                    location_alerts.append(alert_data)
+            
+            results[location] = location_alerts
+            total_alerts += len(location_alerts)
+        
+        return {
+            "status": "success",
+            "total_alerts": total_alerts,
+            "locations_searched": len(locations),
+            "data": results
+        }
+        
+    except Exception as e:
+        return {
+            "status": "error",
+            "message": f"Error processing request: {str(e)}",
+            "data": {}
+        }
+
+def get_alert_summary() -> Dict[str, Any]:
+    """
+    Get summary of all current alerts by severity
+    """
+    try:
+        all_alerts = weather_api.fetch_alerts()
+        
+        if not all_alerts:
+            return {
+                "status": "error",
+                "message": "No alerts found or error fetching data",
+                "summary": {}
+            }
+        
+        summary = {"WARNING": 0, "ALERT": 0, "WATCH": 0, "Yellow": 0, "Orange": 0, "Other": 0}
+        disaster_types = {}
+        states = {}
+        
+        for alert in all_alerts:
+            # Count by severity
+            severity = alert.get("severity", "Other")
+            if severity in summary:
+                summary[severity] += 1
+            else:
+                summary["Other"] += 1
+            
+            # Count by disaster type
+            disaster_type = alert.get("disaster_type", "Unknown")
+            disaster_types[disaster_type] = disaster_types.get(disaster_type, 0) + 1
+            
+            # Count by state (extract from area_description)
+            area_desc = alert.get("area_description", "")
+            if "districts of" in area_desc:
+                state = area_desc.split("districts of")[-1].strip()
+                states[state] = states.get(state, 0) + 1
+        
+        total = sum(summary.values())
+        
+        return {
+            "status": "success",
+            "total_alerts": total,
+            "severity_breakdown": summary,
+            "top_disaster_types": dict(sorted(disaster_types.items(), key=lambda x: x[1], reverse=True)[:10]),
+            "top_affected_states": dict(sorted(states.items(), key=lambda x: x[1], reverse=True)[:10])
+        }
+        
+    except Exception as e:
+        return {
+            "status": "error",
+            "message": f"Error getting summary: {str(e)}",
+            "summary": {}
+        }
+
+def get_available_locations(limit: int = 50) -> Dict[str, Any]:
+    """
+    Get list of locations with current alerts
+    """
+    try:
+        all_alerts = weather_api.fetch_alerts()
+        
+        if not all_alerts:
+            return {
+                "status": "error",
+                "message": "No alerts found or error fetching data",
+                "locations": []
+            }
+        
+        locations = set()
+        for alert in all_alerts:
+            area_desc = alert.get("area_description", "").strip()
+            if area_desc:
+                locations.add(area_desc)
+        
+        sorted_locations = sorted(list(locations))[:limit]
+        
+        return {
+            "status": "success",
+            "total_available": len(locations),
+            "returned": len(sorted_locations),
+            "locations": sorted_locations
+        }
+        
+    except Exception as e:
+        return {
+            "status": "error",
+            "message": f"Error getting locations: {str(e)}",
+            "locations": []
+        }
+
+# Function dispatcher for OpenAI (Updated for tool_calls)
+def execute_function(function_name: str, arguments: Dict[str, Any]) -> Dict[str, Any]:
+    """
+    Execute the appropriate function based on OpenAI's tool call
+    """
+    if function_name == "get_weather_alerts":
+        return get_weather_alerts(**arguments)
+    elif function_name == "get_weather":
+        return get_weather(**arguments)
+    elif function_name == "get_alert_summary":
+        return get_alert_summary(**arguments)
+    elif function_name == "get_available_locations":
+        return get_available_locations(**arguments)
+    else:
+        return {
+            "status": "error",
+            "message": f"Unknown function: {function_name}"
+        }
+
+def chat_with_weather_assistant(user_query: str = "", loop: bool = False, api_key: str = os.getenv("API_KEY"), api_url: str = os.getenv("API_URL"), model_name: str = os.getenv("MODEL_NAME")) -> None:
+    """
+    Chat with the weather alert assistant.
+    
+    Args:
+        user_query (str, optional): The user's query about weather alerts. If empty, will prompt for input.
+        loop (bool, optional): Whether to continue the conversation in a loop. 
+                             If True, will keep asking for new queries until 'quit' is entered.
+                             If False, will process a single query and return. Defaults to False.
+    """
+    if not api_key or not api_url or not model_name:
+        raise ValueError("API key, API URL, and model name are required.")
+        
+    client = OpenAI(api_key=api_key, base_url=api_url)
+    
+    while True:
+        # Get user input if not provided or in loop mode
+        if not user_query:
+            user_input = input("\nAsk about weather alerts (or 'quit' to exit): ")
+            if user_input.lower() == 'quit':
+                break
+        else:
+            user_input = user_query
+            user_query = None  # Clear the query after first use
+        
+        try:
+            # Initial API call
+            response = client.chat.completions.create(
+                model=model_name,
+                messages=[
+                    {
+                        "role": "system", 
+                        "content": "You are a weather information/alert assistant for India. Use the provided functions to help users get weather alert information. Always provide helpful and accurate information about weather alerts. Your respose should be in same language as user query. Response only should in paragraph only there should not be any table or list till user say to show table or list and response should be in easy language which can understand by uneducated person."
+                    },
+                    {"role": "user", "content": user_input}
+                ],
+                tools=WEATHER_TOOLS,
+                tool_choice="auto"
+            )
+            
+            message = response.choices[0].message
+            
+            if hasattr(message, 'tool_calls') and message.tool_calls:
+                # Prepare messages for function execution
+                messages = [
+                    {
+                        "role": "system", 
+                        "content": "You are a weather information/alert assistant for India. Use the provided functions to help users get weather alert information. Always provide helpful and accurate information about weather alerts. Your response should be in the same language as the user query. Response should be in paragraph format only (no tables or lists unless explicitly requested) and in simple language that can be understood by everyone."
+                    },
+                    {"role": "user", "content": user_input},
+                    message  # Add the assistant message with 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)
+                    function_result = execute_function(function_name, function_args)
+                    
+                    messages.append({
+                        "role": "tool",
+                        "tool_call_id": tool_call.id,
+                        "content": json.dumps(function_result)
+                    })
+                
+                # Get final response
+                final_response = client.chat.completions.create(
+                    model=model_name,
+                    messages=messages
+                )
+                
+                final_message = final_response.choices[0].message.content
+                print(f"\n🤖 Assistant: {final_message}")
+                
+            else:
+                print(f"\n🤖 Assistant: {message.content}")
+            
+            # If not in loop mode, break after one iteration
+            if not loop:
+                break
+                
+        except Exception as e:
+            print(f"❌ Error: {e}")
+            if not loop:
+                break
+
+if __name__ == "__main__":
+    chat_with_weather_assistant()
+    # print(WEATHER_TOOLS)
+# get me weather alert of mumbai

easy_agents.py

@@ -0,0 +1,685 @@
+# easy_agents.py
+
+import json
+import requests
+import logging
+from typing import Optional, Dict, Any, Union, List
+from functools import lru_cache
+import time
+
+# Configure logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger(__name__)
+
+class EasyFarmsAgent:
+    """
+    EasyFarms AI Agent optimized for function calling in AI systems.
+    """
+    
+    def __init__(self, timeout: int = 30, max_retries: int = 3):
+        """Initialize the agent with configuration options."""
+        self.timeout = timeout
+        self.max_retries = max_retries
+        
+        # Create a session for connection pooling
+        self.session = requests.Session()
+        self.session.headers.update({
+            'User-Agent': 'EasyFarms-Agent/1.0',
+            'Accept': 'application/json'
+        })
+        
+        # Load mappings
+        self._load_mappings()
+    
+    def _load_mappings(self):
+        """Pre-load all mappings for faster access."""
+        self.soil_mapping = {
+            "black": 0, "clayey": 1, "loamy": 2, "red": 3, "sandy": 4
+        }
+        
+        self.fertilizer_crop_mapping = {
+            "barley": 0, "cotton": 1, "ground nuts": 2, "maize": 3, "millets": 4,
+            "oil seeds": 5, "paddy": 6, "pulses": 7, "sugarcane": 8, "tobacco": 9, "wheat": 10
+        }
+        
+        self.disease_crop_mapping = {
+            "almond": "almond", "aloe": "aloe", "apple": "apple", "apricot": "apricot",
+            "avocado": "avocado", "bamboo": "bamboo", "banana": "banana", "barley": "barley",
+            "bean": "bean", "bitter_gourd": "bitter_gourd", "black_plum": "black_plum",
+            "blackberry": "blackberry", "bottle_gourd": "bottle_gourd", "cabbage": "cabbage",
+            "canola": "canola", "carrot": "carrot", "cashew": "cashew", "cauliflower": "cauliflower",
+            "chard": "chard", "cherry": "cherry", "chickpea": "chickpea", "citrus": "citrus",
+            "cocoa": "cocoa", "coconut": "coconut", "coffee": "coffee", "cotton": "cotton",
+            "cucumber": "cucumber", "currant": "currant", "curry_leaf_tree": "curry_leaf_tree",
+            "date": "date", "eggplant": "eggplant", "fig": "fig", "garlic": "garlic",
+            "ginger": "ginger", "gram": "gram", "grape": "grape", "guava": "guava",
+            "herb": "herb", "jackfruit": "jackfruit", "leek": "leek", "lentil": "lentil",
+            "lettuce": "lettuce", "maize": "maize", "mango": "mango", "manioc": "manioc",
+            "melon": "melon", "millet": "millet", "mustard": "mustard", "okra": "okra",
+            "olive": "olive", "onion": "onion", "papaya": "papaya", "pea": "pea",
+            "peach": "peach", "peanut": "peanut", "pear": "pear", "pepper": "pepper",
+            "pigeonpea": "pigeonpea", "pineapple": "pineapple", "pistachio": "pistachio",
+            "plum": "plum", "pomegranate": "pomegranate", "potato": "potato",
+            "pumpkin": "pumpkin", "radish": "radish", "raspberry": "raspberry",
+            "rice": "rice", "rose": "rose", "rye": "rye", "sorghum": "sorghum",
+            "soybean": "soybean", "strawberry": "strawberry", "sugarbeet": "sugarbeet",
+            "sugarcane": "sugarcane", "sunflower": "sunflower", "sweetpotato": "sweetpotato",
+            "tea": "tea", "tamarind": "tamarind", "tobacco": "tobacco", "tomato": "tomato",
+            "turmeric": "turmeric", "turnip": "turnip", "wheat": "wheat", "zucchini": "zucchini"
+        }
+        
+        self.endpoints = {
+            "crop": "https://nitinbot001-agrigo.hf.space/crop-recommendation",
+            "fertilizer": "https://nitinbot001-agrigo.hf.space/fertilizer-recommendation",
+            "disease": "https://api-for-disease-detection.vercel.app/analyze-plant"
+        }
+
+    def _make_request_with_retry(self, method: str, url: str, **kwargs) -> Dict[str, Any]:
+        """Make HTTP request with retry logic and handle both JSON and HTML responses."""
+        last_exception = None
+        
+        for attempt in range(self.max_retries):
+            try:
+                response = self.session.request(method, url, timeout=self.timeout, **kwargs)
+                response.raise_for_status()
+                
+                content_type = response.headers.get('content-type', '')
+                
+                if 'application/json' in content_type:
+                    try:
+                        return response.json()
+                    except ValueError as e:
+                        error_msg = f"Invalid JSON response: {response.text[:200]}..."
+                        logger.error(error_msg)
+                        raise ValueError(error_msg) from e
+                        
+                elif 'text/html' in content_type:
+                    # Handle HTML response
+                    logger.warning(f"Received HTML response from {url}, attempting to parse...")
+                    return self._parse_html_response(response.text)
+                    
+                else:
+                    error_msg = f"Unexpected content type: {content_type}. Response: {response.text[:200]}..."
+                    logger.error(error_msg)
+                    raise ValueError(error_msg)
+                    
+            except requests.exceptions.RequestException as e:
+                last_exception = e
+                if attempt < self.max_retries - 1:
+                    wait_time = (attempt + 1) * 2
+                    logger.warning(f"Request failed (attempt {attempt + 1}), retrying in {wait_time}s: {e}")
+                    time.sleep(wait_time)
+        
+        raise last_exception or Exception("Failed to get valid response after retries")
+
+    def _parse_html_response(self, html_content: str) -> Dict[str, Any]:
+        """
+        Parse HTML response to extract the recommendation from the specified selector path.
+        """
+        try:
+            from bs4 import BeautifulSoup
+        except ImportError:
+            return {
+                'status': 'error',
+                'message': 'BeautifulSoup4 is required for HTML parsing. Install it with: pip install beautifulsoup4',
+                'raw_html': html_content[:500] + '...'
+            }
+        
+        try:
+            soup = BeautifulSoup(html_content, 'html.parser')
+            result = {}
+            
+            # Extract recommendation using the specified CSS selector
+            recommendation = soup.select_one("body > div > div > h3 > b > span")
+            
+            if recommendation:
+                result['prediction'] = recommendation.text.strip()
+                result['status'] = 'success'
+            else:
+                # Try to find any error messages if the recommendation isn't found
+                error_msg = soup.find('div', class_='error') or soup.find('p', class_='error')
+                if error_msg:
+                    result['error'] = error_msg.text.strip()
+                else:
+                    result['error'] = 'No recommendation found in the response'
+                
+                result['status'] = 'error'
+                result['raw_html'] = html_content[:500] + '...'
+            
+            return result
+            
+        except Exception as e:
+            return {
+                'status': 'error',
+                'message': f'Error parsing HTML response: {str(e)}',
+                'raw_html': html_content[:500] + '...'
+            }
+
+# Global agent instance
+_easyfarms_agent = EasyFarmsAgent()
+
+# =============================================================================
+# FUNCTION DEFINITIONS FOR AI AGENTS
+# =============================================================================
+
+# Function schemas for AI agent function calling
+EASYFARMS_FUNCTION_SCHEMAS = [
+    {
+        "name": "get_crop_recommendation",
+        "description": "Get crop recommendation based on soil nutrients (N, P, K) and environmental conditions. Returns the best crop to grow given current soil and weather conditions.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "N": {
+                    "type": "integer",
+                    "description": "Nitrogen content in soil (ppm)",
+                    "minimum": 0,
+                    "maximum": 200
+                },
+                "P": {
+                    "type": "integer", 
+                    "description": "Phosphorous content in soil (ppm)",
+                    "minimum": 0,
+                    "maximum": 150
+                },
+                "K": {
+                    "type": "integer",
+                    "description": "Potassium content in soil (ppm)", 
+                    "minimum": 0,
+                    "maximum": 300
+                },
+                "temperature": {
+                    "type": "number",
+                    "description": "Temperature in Celsius",
+                    "minimum": -10,
+                    "maximum": 50
+                },
+                "humidity": {
+                    "type": "number", 
+                    "description": "Relative humidity percentage",
+                    "minimum": 0,
+                    "maximum": 100
+                },
+                "ph": {
+                    "type": "number",
+                    "description": "Soil pH level",
+                    "minimum": 0,
+                    "maximum": 14
+                },
+                "rainfall": {
+                    "type": "number",
+                    "description": "Average rainfall in mm (default: 100)",
+                    "minimum": 0,
+                    "maximum": 500,
+                    "default": 100
+                }
+            },
+            "required": ["N", "P", "K", "temperature", "humidity"]
+        }
+    },
+    {
+        "name": "get_fertilizer_recommendation",
+        "description": "Get fertilizer recommendation for a specific crop based on soil conditions and nutrient levels. Returns the best fertilizer type to use.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "crop": {
+                    "type": "string",
+                    "description": "Crop type",
+                    "enum": ["barley", "cotton", "ground nuts", "maize", "millets", "oil seeds", "paddy", "pulses", "sugarcane", "tobacco", "wheat"]
+                },
+                "soil": {
+                    "type": "string", 
+                    "description": "Soil type",
+                    "enum": ["black", "clayey", "loamy", "red", "sandy"]
+                },
+                "temperature": {
+                    "type": "number",
+                    "description": "Temperature in Celsius",
+                    "minimum": -10,
+                    "maximum": 50
+                },
+                "humidity": {
+                    "type": "number",
+                    "description": "Relative humidity percentage",
+                    "minimum": 0,
+                    "maximum": 100
+                },
+                "moisture": {
+                    "type": "number",
+                    "description": "Soil moisture percentage",
+                    "minimum": 0,
+                    "maximum": 100
+                },
+                "N": {
+                    "type": "integer",
+                    "description": "Nitrogen content in soil (ppm)",
+                    "minimum": 0,
+                    "maximum": 200
+                },
+                "P": {
+                    "type": "integer",
+                    "description": "Phosphorous content in soil (ppm)", 
+                    "minimum": 0,
+                    "maximum": 150
+                },
+                "K": {
+                    "type": "integer",
+                    "description": "Potassium content in soil (ppm)",
+                    "minimum": 0,
+                    "maximum": 300
+                }
+            },
+            "required": ["crop", "soil", "temperature", "humidity", "moisture", "N", "P", "K"]
+        }
+    },
+    {
+        "name": "detect_plant_disease",
+        "description": "Detect plant diseases from an image of a plant leaf or crop. Analyzes the image to identify potential diseases and provides treatment recommendations.",
+        "parameters": {
+            "type": "object", 
+            "properties": {
+                "crop": {
+                    "type": "string",
+                    "description": "Type of crop/plant in the image",
+                    "enum": ["almond", "aloe", "apple", "apricot", "avocado", "bamboo", "banana", "barley", "bean", "bitter_gourd", "black_plum", "blackberry", "bottle_gourd", "cabbage", "canola", "carrot", "cashew", "cauliflower", "chard", "cherry", "chickpea", "citrus", "cocoa", "coconut", "coffee", "cotton", "cucumber", "currant", "curry_leaf_tree", "date", "eggplant", "fig", "garlic", "ginger", "gram", "grape", "guava", "herb", "jackfruit", "leek", "lentil", "lettuce", "maize", "mango", "manioc", "melon", "millet", "mustard", "okra", "olive", "onion", "papaya", "pea", "peach", "peanut", "pear", "pepper", "pigeonpea", "pineapple", "pistachio", "plum", "pomegranate", "potato", "pumpkin", "radish", "raspberry", "rice", "rose", "rye", "sorghum", "soybean", "strawberry", "sugarbeet", "sugarcane", "sunflower", "sweetpotato", "tea", "tamarind", "tobacco", "tomato", "turmeric", "turnip", "wheat", "zucchini"]
+                },
+                "image_path": {
+                    "type": "string",
+                    "description": "Path to the plant/leaf image file"
+                },
+                "language": {
+                    "type": "string",
+                    "description": "Response language code (default: 'en')",
+                    "default": "en",
+                    "enum": ["en", "hi", "es", "fr", "de"]
+                }
+            },
+            "required": ["crop", "image_path"]
+        }
+    },
+    {
+        "name": "get_supported_options",
+        "description": "Get lists of supported crops and soil types for different analysis modes. Useful for showing available options to users.",
+        "parameters": {
+            "type": "object",
+            "properties": {
+                "mode": {
+                    "type": "string",
+                    "description": "Mode to get supported options for",
+                    "enum": ["fertilizer_crops", "disease_crops", "soil_types", "all"]
+                }
+            },
+            "required": ["mode"]
+        }
+    }
+]
+
+# =============================================================================
+# 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
+}
+
+# =============================================================================
+# UTILITY FUNCTIONS FOR AI AGENT INTEGRATION
+# =============================================================================
+
+def execute_easyfarms_function(function_name: str, **kwargs) -> Dict[str, Any]:
+    """
+    Execute an EasyFarms function by name with given parameters.
+    
+    Args:
+        function_name: Name of the function to execute
+        **kwargs: Function parameters
+    
+    Returns:
+        Function execution result
+    """
+    if function_name not in EASYFARMS_FUNCTIONS:
+        return {
+            "error": f"Unknown function: {function_name}. Available: {list(EASYFARMS_FUNCTIONS.keys())}",
+            "status": "error"
+        }
+    
+    try:
+        return EASYFARMS_FUNCTIONS[function_name](**kwargs)
+    except TypeError as e:
+        return {
+            "error": f"Invalid parameters for {function_name}: {str(e)}",
+            "status": "error"
+        }
+    except Exception as e:
+        return {
+            "error": f"Execution failed for {function_name}: {str(e)}",
+            "status": "error"
+        }
+
+def get_function_schemas() -> List[Dict]:
+    """Get all function schemas for AI agent registration."""
+    return EASYFARMS_FUNCTION_SCHEMAS
+
+def get_function_names() -> List[str]:
+    """Get list of available function names."""
+    return list(EASYFARMS_FUNCTIONS.keys())
+
+# =============================================================================
+# EXAMPLE USAGE FOR AI AGENTS
+# =============================================================================
+
+if __name__ == "__main__":
+    # Example of how to use in an AI agent
+    
+    print("=== EasyFarms Function Schemas ===")
+    schemas = get_function_schemas()
+    for schema in schemas:
+        print(f"Function: {schema['name']}")
+        print(f"Description: {schema['description']}")
+        print()
+    
+    print("=== Example Function Calls ===")
+    
+    # Crop recommendation
+    crop_result = execute_easyfarms_function(
+        "get_crop_recommendation",
+        N=90, P=42, K=43,
+        temperature=20.87,
+        humidity=82.0,
+        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))

weatherr.py

@@ -0,0 +1,79 @@
+# weatherr.py
+
+import requests
+import os
+from dotenv import load_dotenv
+load_dotenv()
+
+# Replace with your API keys
+OPENCAGE_API_KEY = os.getenv("OPENCAGE_API_KEY")
+OPENWEATHER_API_KEY = os.getenv("OPENWEATHER_API_KEY")
+
+def get_weather(
+    latitude: float = None,
+    longitude: float = None,
+    address: str = None,
+    district: str = None,
+    state: str = None,
+    units: str = "metric"  # "metric" or "imperial"
+) -> dict:
+    """
+    Fetch current weather using coordinates or location name (address/district/state).
+
+    Returns structured weather info from OpenWeatherMap.
+    """
+    # Step 1: Determine coordinates
+    if latitude is None or longitude is None:
+        if address:
+            query = address
+        elif district and state:
+            query = f"{district}, {state}"
+        elif district:
+            query = district
+        else:
+            return {"error": "Provide either coordinates or location name (address/district+state)."}
+
+        # Use OpenCageData geocoding
+        geocode_url = "https://api.opencagedata.com/geocode/v1/json"
+        params = {
+            "q": query,
+            "key": OPENCAGE_API_KEY,
+            "limit": 1,
+            "no_annotations": 1
+        }
+        try:
+            resp = requests.get(geocode_url, params=params, timeout=10)
+            resp.raise_for_status()
+            data = resp.json()
+            if data["results"]:
+                latitude = data["results"][0]["geometry"]["lat"]
+                longitude = data["results"][0]["geometry"]["lng"]
+            else:
+                return {"error": f"Location not found: {query}"}
+        except Exception as e:
+            return {"error": f"Geocoding error: {e}"}
+
+    # Step 2: Fetch weather from OpenWeatherMap
+    weather_url = "https://api.openweathermap.org/data/2.5/weather"
+    params = {
+        "lat": latitude,
+        "lon": longitude,
+        "appid": OPENWEATHER_API_KEY,
+        "units": units
+    }
+
+    try:
+        resp = requests.get(weather_url, params=params, timeout=10)
+        resp.raise_for_status()
+        return {"success": True, "data": resp.json()}
+    except Exception as e:
+        return {"error": f"Weather API error: {e}"}
+
+# Example usage:
+if __name__ == "__main__":
+    res = get_weather(district="Bilaspur", state="Chhattisgarh")
+    res2 = get_weather(latitude=22.0934, longitude=82.1564)
+    res3 = get_weather(address="Bilaspur, Chhattisgarh")
+    print(res)
+    print(res2)
+    print(res3)