t

a2a_agents/alert_agent.py

@@ -0,0 +1,63 @@
+import asyncio
+from src.mcp_weather_server.tools import alert_generation_tools
+from unittest.mock import patch
+
+class AlertAgent:
+    async def generate_alert(self, crop, weather_data, growth_stage, latitude, longitude):
+        with patch('src.mcp_weather_server.tools.openai_llm.predict_weather_alert') as mock_predict_weather_alert:
+            # Mock the alert generation
+            mock_predict_weather_alert.return_value = {
+                "alert": "Heavy rainfall expected",
+                "impact": "High risk of waterlogging in fields.",
+                "recommendations": "Ensure proper drainage in fields."
+            }
+
+            print("Generating weather alert...")
+            api_key = "test_api_key"  # This will be mocked, so the value doesn't matter
+            alert_response = await alert_generation_tools.generate_weather_alert(
+                crop=crop,
+                weather_data=weather_data,
+                growth_stage=growth_stage,
+                api_key=api_key,
+                latitude=latitude,
+                longitude=longitude
+            )
+            return alert_response
+
+async def main():
+    agent = AlertAgent()
+    # Example usage
+    crop = "Wheat"
+    growth_stage = "Flowering"
+    lat = 25.6
+    lon = 85.1
+    # Mock weather data for the example
+    weather_data = {
+        "daily": {
+            "time": ["2024-02-15", "2024-02-16"],
+            "temperature_2m_max": [25, 26],
+            "temperature_2m_min": [12, 13],
+            "precipitation_sum": [0, 5]
+        }
+    }
+
+    alert = await agent.generate_alert(
+        crop=crop,
+        weather_data=weather_data,
+        growth_stage=growth_stage,
+        latitude=lat,
+        longitude=lon
+    )
+
+    if alert and "error" not in alert:
+        print("\n--- Generated Weather Alert ---")
+        print(f"Alert: {alert['alert']}")
+        print(f"Impact: {alert['impact']}")
+        print(f"Recommendations: {alert['recommendations']}")
+        print("-----------------------------")
+    elif alert and "error" in alert:
+        print(f"Error generating alert: {alert['error']}")
+
+
+if __name__ == "__main__":
+    asyncio.run(main())

a2a_agents/crop_agent.py

@@ -0,0 +1,53 @@
+import asyncio
+from src.mcp_weather_server.tools import crop_calendar_tools
+import datetime
+
+class CropAgent:
+    def get_current_season(self):
+        # This is a simplified way to determine the season.
+        # A more robust implementation would use a more accurate method.
+        month = datetime.datetime.now().month
+        if month >= 10 or month <= 3:
+            return "Rabi"
+        else:
+            return "Kharif"
+
+    async def get_crop_info(self, state, season, plant_date, current_date):
+        print(f"Finding prominent crops for {season} season in {state}...")
+        prominent_crops_response = await crop_calendar_tools.get_prominent_crops(region=state, season=season)
+        if "error" in prominent_crops_response:
+            print(f"Error: {prominent_crops_response['error']}")
+            return None
+
+        crop_info_list = []
+        for crop in prominent_crops_response["crops"]:
+            print(f"Estimating crop stage for {crop} planted on {plant_date}...")
+            crop_stage_response = await crop_calendar_tools.estimate_crop_stage(crop=crop, plant_date=plant_date, current_date=current_date)
+            if "error" in crop_stage_response:
+                print(f"Error: {crop_stage_response['error']}")
+                continue
+
+            crop_info_list.append({
+                "crop": crop,
+                "growth_stage": crop_stage_response["stage"]
+            })
+        return crop_info_list
+
+async def main():
+    agent = CropAgent()
+    season = agent.get_current_season()
+    print(f"Current season: {season}")
+
+    # Example usage
+    plant_date = "2023-11-01"
+    current_date = "2024-02-15"
+    crop_info = await agent.get_crop_info(state="bihar", season=season, plant_date=plant_date, current_date=current_date)
+
+    if crop_info:
+        print("\n--- Crop Info ---")
+        for info in crop_info:
+            print(f"Crop: {info['crop']}, Growth Stage: {info['growth_stage']}")
+        print("-----------------")
+
+if __name__ == "__main__":
+    asyncio.run(main())

a2a_agents/ivr_agent.py

@@ -0,0 +1,62 @@
+def create_ivr_script(alert_json: dict) -> list[dict]:
+    """
+    Creates a voice script with timing from a structured alert JSON.
+    """
+
+    script = [
+        {"text": f"Namaste. Mausam ki chetavani {alert_json['location']['district']} ke liye.", "delay_after": 1},
+        {"text": f"Fasal: {alert_json['crop']['name']}.", "delay_after": 1},
+        {"text": f"Chetavani: {alert_json['alert']['message']}", "delay_after": 2},
+        {"text": "Salah ke liye, ek dabaye.", "delay_after": 0}
+    ]
+    return script
+
+def get_ivr_submenu_script(alert_json: dict) -> list[dict]:
+    """
+    Returns a submenu script for the IVR.
+    """
+    actions = ". ".join([action.replace('_', ' ') for action in alert_json['alert']['action_items']])
+    script = [
+        {"text": f"Salah: {actions}", "delay_after": 2},
+        {"text": "Dhanyavad.", "delay_after": 0}
+    ]
+    return script
+
+if __name__ == '__main__':
+    sample_alert = {
+      "alert_id": "BH_PAT_001_20250723",
+      "timestamp": "2025-07-23T06:00:00Z",
+      "location": {
+        "village": "Kumhrar",
+        "district": "Patna",
+        "state": "Bihar",
+        "coordinates": [25.5941, 85.1376]
+      },
+      "crop": {
+        "name": "rice",
+        "stage": "flowering",
+        "planted_estimate": "2025-06-15"
+      },
+      "alert": {
+        "type": "weather_warning",
+        "urgency": "high",
+        "message": "Heavy rainfall (40-60mm) expected in next 2 days. Delay fertilizer application. Ensure proper drainage.",
+        "action_items": ["delay_fertilizer", "check_drainage"],
+        "valid_until": "2025-07-25T18:00:00Z"
+      },
+      "weather": {
+        "forecast_days": 3,
+        "rain_probability": 85,
+        "expected_rainfall": "45mm"
+      }
+    }
+
+    main_script = create_ivr_script(sample_alert)
+    print("--- Main Script ---")
+    for line in main_script:
+        print(line)
+
+    submenu_script = get_ivr_submenu_script(sample_alert)
+    print("\n--- Submenu Script ---")
+    for line in submenu_script:
+        print(line)

a2a_agents/location_agent.py

@@ -0,0 +1,37 @@
+import asyncio
+from src.mcp_weather_server.tools import geographic_tools
+
+class LocationAgent:
+    async def get_locations(self, state, district):
+        print(f"Fetching villages for {district}, {state}...")
+        villages_response = await geographic_tools.list_villages(state=state, district=district)
+        if "error" in villages_response:
+            print(f"Error: {villages_response['error']}")
+            return None
+
+        locations = []
+        for village in villages_response["villages"]:
+            print(f"Getting coordinates for {village}...")
+            coordinates_response = await geographic_tools.reverse_geocode(location_name=village)
+            if "error" in coordinates_response:
+                print(f"Error: {coordinates_response['error']}")
+                continue
+
+            locations.append({
+                "village": village,
+                "latitude": coordinates_response["latitude"],
+                "longitude": coordinates_response["longitude"]
+            })
+        return locations
+
+async def main():
+    agent = LocationAgent()
+    locations = await agent.get_locations(state="bihar", district="patna")
+    if locations:
+        print("\n--- Locations ---")
+        for loc in locations:
+            print(f"Village: {loc['village']}, Lat: {loc['latitude']}, Lon: {loc['longitude']}")
+        print("-----------------")
+
+if __name__ == "__main__":
+    asyncio.run(main())

a2a_agents/sms_agent.py

@@ -0,0 +1,69 @@
+import json
+
+def to_hindi(text):
+    """
+    Mock function to "translate" text to Hindi.
+    In a real implementation, this would use a translation service.
+    """
+    translations = {
+        "Heavy rainfall": "भारी वर्षा",
+        "expected in next 2 days.": "अगले 2 दिनों में अपेक्षित।",
+        "Delay fertilizer application.": "उर्वरक आवेदन में देरी करें।",
+        "Ensure proper drainage.": "उचित जल निकासी सुनिश्चित करें।",
+        "rice": "चावल",
+        "flowering": "फूल",
+        "weather_warning": "मौसम की चेतावनी",
+        "high": "उच्च",
+        "Kumhrar": "कुम्हरार",
+        "Patna": "पटना",
+        "Bihar": "बिहार",
+        "Alert": "चेतावनी",
+        "Crop": "फसल",
+        "Stage": "चरण",
+        "Urgency": "तात्कालिकता",
+        "Action": "कार्य"
+    }
+    for en, hi in translations.items():
+        text = text.replace(en, hi)
+    return text
+
+def create_sms_message(alert_json: dict) -> str:
+    """
+    Creates a 160-character SMS message from a structured alert JSON.
+    """
+
+    message = (
+        f"{to_hindi('Alert')}: {to_hindi(alert_json['alert']['type'])}, "
+        f"{to_hindi('Crop')}: {to_hindi(alert_json['crop']['name'])}, "
+        f"{to_hindi('Stage')}: {to_hindi(alert_json['crop']['stage'])}, "
+        f"{to_hindi('Urgency')}: {to_hindi(alert_json['alert']['urgency'])}. "
+        f"{to_hindi(alert_json['alert']['message'])}"
+    )
+
+    # Truncate to 160 characters
+    return message[:160]
+
+if __name__ == '__main__':
+    sample_alert = {
+      "alert_id": "BH_PAT_001_20250723",
+      "timestamp": "2025-07-23T06:00:00Z",
+      "location": {
+        "village": "Kumhrar",
+        "district": "Patna",
+        "state": "Bihar",
+        "coordinates": [25.5941, 85.1376]
+      },
+      "crop": {
+        "name": "rice",
+        "stage": "flowering"
+      },
+      "alert": {
+        "type": "weather_warning",
+        "urgency": "high",
+        "message": "Heavy rainfall expected in next 2 days. Delay fertilizer application. Ensure proper drainage."
+      }
+    }
+
+    sms = create_sms_message(sample_alert)
+    print(sms)
+    print(f"Length: {len(sms)}")

a2a_agents/telegram_agent.py

@@ -0,0 +1,63 @@
+import json
+
+def create_telegram_message(alert_json: dict) -> dict:
+    """
+    Creates a Telegram message with an inline keyboard from a structured alert JSON.
+    """
+
+    message = (
+        f"🚨 *Weather Alert* 🚨\n\n"
+        f"📍 *Location:* {alert_json['location']['village']}, {alert_json['location']['district']}\n"
+        f"🌾 *Crop:* {alert_json['crop']['name'].capitalize()} ({alert_json['crop']['stage']})\n"
+        f"⚠️ *Urgency:* {alert_json['alert']['urgency'].upper()}\n\n"
+        f"📝 *Details:* {alert_json['alert']['message']}\n\n"
+        f"✅ *Recommended Actions:*\n"
+    )
+    for action in alert_json['alert']['action_items']:
+        message += f"- {action.replace('_', ' ').capitalize()}\n"
+
+    keyboard = {
+        "inline_keyboard": [
+            [
+                {"text": "Acknowledge", "callback_data": f"ack_{alert_json['alert_id']}"},
+                {"text": "More Info", "callback_data": f"info_{alert_json['alert_id']}"}
+            ]
+        ]
+    }
+
+    return {
+        "text": message,
+        "reply_markup": keyboard
+    }
+
+if __name__ == '__main__':
+    sample_alert = {
+      "alert_id": "BH_PAT_001_20250723",
+      "timestamp": "2025-07-23T06:00:00Z",
+      "location": {
+        "village": "Kumhrar",
+        "district": "Patna",
+        "state": "Bihar",
+        "coordinates": [25.5941, 85.1376]
+      },
+      "crop": {
+        "name": "rice",
+        "stage": "flowering",
+        "planted_estimate": "2025-06-15"
+      },
+      "alert": {
+        "type": "weather_warning",
+        "urgency": "high",
+        "message": "Heavy rainfall (40-60mm) expected in next 2 days. Delay fertilizer application. Ensure proper drainage.",
+        "action_items": ["delay_fertilizer", "check_drainage"],
+        "valid_until": "2025-07-25T18:00:00Z"
+      },
+      "weather": {
+        "forecast_days": 3,
+        "rain_probability": 85,
+        "expected_rainfall": "45mm"
+      }
+    }
+
+    telegram_message = create_telegram_message(sample_alert)
+    print(json.dumps(telegram_message, indent=2))

a2a_agents/ussd_agent.py

@@ -0,0 +1,71 @@
+def create_ussd_menu(alert_json: dict) -> str:
+    """
+    Creates a USSD menu from a structured alert JSON.
+    """
+
+    menu = (
+        "Mausam ki jankari:\n"
+        f"1. {alert_json['crop']['name'].capitalize()} ki chetavani\n"
+        "2. Salah\n"
+        "3. Exit"
+    )
+    return menu
+
+def get_ussd_submenu(alert_json: dict, choice: int) -> str:
+    """
+    Returns a submenu based on the user's choice.
+    """
+    if choice == 1:
+        return (
+            f"Chetavani: {alert_json['alert']['message']}\n"
+            "0. Back"
+        )
+    elif choice == 2:
+        actions = "\n".join([f"- {action.replace('_', ' ').capitalize()}" for action in alert_json['alert']['action_items']])
+        return (
+            f"Salah:\n{actions}\n"
+            "0. Back"
+        )
+    else:
+        return "Invalid choice. Please try again."
+
+if __name__ == '__main__':
+    sample_alert = {
+      "alert_id": "BH_PAT_001_20250723",
+      "timestamp": "2025-07-23T06:00:00Z",
+      "location": {
+        "village": "Kumhrar",
+        "district": "Patna",
+        "state": "Bihar",
+        "coordinates": [25.5941, 85.1376]
+      },
+      "crop": {
+        "name": "rice",
+        "stage": "flowering",
+        "planted_estimate": "2025-06-15"
+      },
+      "alert": {
+        "type": "weather_warning",
+        "urgency": "high",
+        "message": "Heavy rainfall (40-60mm) expected in next 2 days. Delay fertilizer application. Ensure proper drainage.",
+        "action_items": ["delay_fertilizer", "check_drainage"],
+        "valid_until": "2025-07-25T18:00:00Z"
+      },
+      "weather": {
+        "forecast_days": 3,
+        "rain_probability": 85,
+        "expected_rainfall": "45mm"
+      }
+    }
+
+    main_menu = create_ussd_menu(sample_alert)
+    print("--- Main Menu ---")
+    print(main_menu)
+
+    submenu_1 = get_ussd_submenu(sample_alert, 1)
+    print("\n--- Submenu 1 ---")
+    print(submenu_1)
+
+    submenu_2 = get_ussd_submenu(sample_alert, 2)
+    print("\n--- Submenu 2 ---")
+    print(submenu_2)

a2a_agents/weather_agent.py

@@ -0,0 +1,26 @@
+import asyncio
+from src.mcp_weather_server.tools import open_meteo
+
+class WeatherAgent:
+    async def get_weather_forecast(self, latitude, longitude):
+        print("Fetching 7-day weather forecast...")
+        weather_forecast_response = await open_meteo.get_weather_forecast(latitude=latitude, longitude=longitude)
+        if "error" in weather_forecast_response:
+            print(f"Error: {weather_forecast_response['error']}")
+            return None
+        print("Weather forecast received.")
+        return weather_forecast_response
+
+async def main():
+    agent = WeatherAgent()
+    # Example usage (Patna, Bihar)
+    lat = 25.6
+    lon = 85.1
+    forecast = await agent.get_weather_forecast(latitude=lat, longitude=lon)
+    if forecast:
+        print("\n--- Weather Forecast ---")
+        print(forecast)
+        print("----------------------")
+
+if __name__ == "__main__":
+    asyncio.run(main())

a2a_agents/whatsapp_agent.py

@@ -0,0 +1,57 @@
+import json
+
+def create_whatsapp_message(alert_json: dict) -> dict:
+    """
+    Creates a rich formatted WhatsApp message from a structured alert JSON.
+    """
+
+    message = (
+        f"🚨 *Weather Alert* 🚨\n\n"
+        f"📍 *Location:* {alert_json['location']['village']}, {alert_json['location']['district']}\n"
+        f"🌾 *Crop:* {alert_json['crop']['name'].capitalize()} ({alert_json['crop']['stage']})\n"
+        f"⚠️ *Urgency:* {alert_json['alert']['urgency'].upper()}\n\n"
+        f"📝 *Details:* {alert_json['alert']['message']}\n\n"
+        f"✅ *Recommended Actions:*\n"
+    )
+    for action in alert_json['alert']['action_items']:
+        message += f"- {action.replace('_', ' ').capitalize()}\n"
+
+    return {
+        "text": message,
+        "buttons": [
+            {"title": "Acknowledge", "payload": f"ack_{alert_json['alert_id']}"},
+            {"title": "More Info", "payload": f"info_{alert_json['alert_id']}"}
+        ]
+    }
+
+if __name__ == '__main__':
+    sample_alert = {
+      "alert_id": "BH_PAT_001_20250723",
+      "timestamp": "2025-07-23T06:00:00Z",
+      "location": {
+        "village": "Kumhrar",
+        "district": "Patna",
+        "state": "Bihar",
+        "coordinates": [25.5941, 85.1376]
+      },
+      "crop": {
+        "name": "rice",
+        "stage": "flowering",
+        "planted_estimate": "2025-06-15"
+      },
+      "alert": {
+        "type": "weather_warning",
+        "urgency": "high",
+        "message": "Heavy rainfall (40-60mm) expected in next 2 days. Delay fertilizer application. Ensure proper drainage.",
+        "action_items": ["delay_fertilizer", "check_drainage"],
+        "valid_until": "2025-07-25T18:00:00Z"
+      },
+      "weather": {
+        "forecast_days": 3,
+        "rain_probability": 85,
+        "expected_rainfall": "45mm"
+      }
+    }
+
+    whatsapp_message = create_whatsapp_message(sample_alert)
+    print(json.dumps(whatsapp_message, indent=2))

requirements.txt

@@ -0,0 +1,7 @@
+fastapi
+uvicorn
+requests
+python-dotenv
+google-search-results
+httpx
+openai

server.py

@@ -0,0 +1,581 @@
+import os
+import logging
+import random
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from dotenv import dotenv_values
+import asyncio
+from datetime import datetime, timedelta
+import csv
+from io import StringIO
+
+
+from tools import open_meteo, tomorrow_io, google_weather, openweathermap, accuweather, openai_llm, geographic_tools, crop_calendar_tools, alert_generation_tools
+from a2a_agents import sms_agent, whatsapp_agent, ussd_agent, ivr_agent, telegram_agent
+from utils.weather_utils import get_tool_config
+
+
+config = dotenv_values(".env")
+
+LOG_LEVEL = os.getenv("LOG_LEVEL", "INFO")
+logging.basicConfig(level=LOG_LEVEL)
+logger = logging.getLogger(__name__)
+
+app = FastAPI()
+
+# CORS middleware for frontend
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["https://mcp-ui.vercel.app"],
+    allow_credentials=True,
+    allow_methods=["GET", "POST", "PUT", "DELETE", "OPTIONS"],
+    allow_headers=["*"],
+    expose_headers=["*"]
+)
+
+class MCPRequest(BaseModel):
+    tool: str
+    parameters: dict
+
+class AlertRequest(BaseModel):
+    alert_json: dict
+
+class WorkflowRequest(BaseModel):
+    state: str
+    district: str
+
+def get_regional_crop_for_area(district: str, state: str):
+    """Get typical crop for the region"""
+    if state.lower() == 'bihar':
+        district_crops = {
+            'patna': 'rice',
+            'gaya': 'wheat',
+            'bhagalpur': 'rice',
+            'muzaffarpur': 'sugarcane',
+            'darbhanga': 'rice',
+            'siwan': 'rice',
+            'begusarai': 'rice',
+            'katihar': 'maize',
+        }
+        return district_crops.get(district.lower(), 'rice')
+    return 'rice'
+
+def get_current_crop_stage(crop: str):
+    """Determine crop stage based on current date"""
+    current_month = datetime.now().month
+    
+    if crop == 'rice':
+        if current_month in [6, 7]:
+            return 'planting'
+        elif current_month in [8, 9]:
+            return 'growing'
+        elif current_month in [10, 11]:
+            return 'flowering'
+        else:
+            return 'harvesting'
+    elif crop == 'wheat':
+        if current_month in [11, 12]:
+            return 'planting'
+        elif current_month in [1, 2]:
+            return 'growing'
+        elif current_month in [3, 4]:
+            return 'flowering'
+        else:
+            return 'harvesting'
+    elif crop == 'sugarcane':
+        if current_month in [2, 3, 4]:
+            return 'planting'
+        elif current_month in [5, 6, 7, 8]:
+            return 'growing'
+        elif current_month in [9, 10, 11]:
+            return 'maturing'
+        else:
+            return 'harvesting'
+    elif crop == 'maize':
+        if current_month in [6, 7]:
+            return 'planting'
+        elif current_month in [8, 9]:
+            return 'growing'
+        elif current_month in [10, 11]:
+            return 'flowering'
+        else:
+            return 'harvesting'
+    
+    return 'growing'
+
+async def generate_dynamic_alert(district: str, state: str):
+    """Generate dynamic alert data using geographic functions and REAL weather data"""
+    
+    try:
+        # Get villages for the district
+        villages_data = await geographic_tools.list_villages(state, district)
+        
+        # Pick a random village or use default
+        village_name = f"Village in {district}"
+        if "villages" in villages_data and villages_data["villages"]:
+            village_name = random.choice(villages_data["villages"])
+            # Avoid village name being same as district
+            if village_name.lower() == district.lower() and len(villages_data["villages"]) > 1:
+                other_villages = [v for v in villages_data["villages"] if v.lower() != district.lower()]
+                if other_villages:
+                    village_name = random.choice(other_villages)
+        
+        # Get coordinates for the district/village
+        location_coords = [25.5941, 85.1376]  # Default to Patna
+        
+        # Try to get coordinates for the district first
+        try:
+            district_location = await geographic_tools.reverse_geocode(district)
+            if "error" not in district_location and "lat" in district_location:
+                location_coords = [district_location["lat"], district_location["lng"]]
+        except:
+            pass  # Keep default coordinates
+        
+        # Generate regional crop and stage
+        regional_crop = get_regional_crop_for_area(district, state)
+        crop_stage = get_current_crop_stage(regional_crop)
+        
+        # GET WEATHER DATA 
+        try:
+            current_weather_data = await open_meteo.get_current_weather(
+                latitude=location_coords[0], 
+                longitude=location_coords[1]
+            )
+            
+            forecast_data = await open_meteo.get_weather_forecast(
+                latitude=location_coords[0], 
+                longitude=location_coords[1],
+                days=7
+            )
+            
+            current_weather = current_weather_data.get('current_weather', {})
+            daily_forecast = forecast_data.get('daily', {})
+            
+            current_temp = current_weather.get('temperature', 25)
+            current_windspeed = current_weather.get('windspeed', 10)
+            
+            precipitation_list = daily_forecast.get('precipitation_sum', [0, 0, 0])
+            next_3_days_rain = sum(precipitation_list[:3]) if precipitation_list else 0
+            
+            rain_probability = min(90, max(10, int(next_3_days_rain * 10))) if next_3_days_rain > 0 else 10
+            
+            # Higher precipitation = higher humidity estimate
+            estimated_humidity = min(95, max(40, 60 + int(next_3_days_rain * 2)))
+            
+            real_weather = {
+                "forecast_days": 3,
+                "rain_probability": rain_probability,
+                "expected_rainfall": f"{next_3_days_rain:.1f}mm",
+                "temperature": f"{current_temp:.1f}°C",
+                "humidity": f"{estimated_humidity}%",
+                "wind_speed": f"{current_windspeed:.1f} km/h"
+            }
+            
+            # Generate alert message based on weather conditions
+            if next_3_days_rain > 25:
+                alert_type = "heavy_rain_warning"
+                urgency = "high"
+                alert_message = f"Heavy rainfall ({next_3_days_rain:.1f}mm) expected in next 3 days in {district}. Delay fertilizer application. Ensure proper drainage."
+                action_items = ["delay_fertilizer", "check_drainage", "monitor_crops", "prepare_harvest_protection"]
+            elif next_3_days_rain > 10:
+                alert_type = "moderate_rain_warning"
+                urgency = "medium"
+                alert_message = f"Moderate rainfall ({next_3_days_rain:.1f}mm) expected in next 3 days in {district}. Monitor soil moisture levels."
+                action_items = ["monitor_soil", "check_drainage", "adjust_irrigation"]
+            elif next_3_days_rain < 2 and current_temp > 35:
+                alert_type = "heat_drought_warning"
+                urgency = "high"
+                alert_message = f"High temperature ({current_temp:.1f}°C) with minimal rainfall expected in {district}. Increase irrigation frequency."
+                action_items = ["increase_irrigation", "mulch_crops", "monitor_plant_stress"]
+            else:
+                alert_type = "weather_update"
+                urgency = "low"
+                alert_message = f"Normal weather conditions expected in {district}. Temperature {current_temp:.1f}°C, rainfall {next_3_days_rain:.1f}mm."
+                action_items = ["routine_monitoring", "maintain_irrigation"]
+            
+            logger.info(f"Real weather data retrieved for {district}: {current_temp}°C, {next_3_days_rain:.1f}mm rain")
+            
+        except Exception as weather_error:
+            logger.error(f"Failed to get real weather data for {district}: {weather_error}")
+            raise Exception(f"Unable to retrieve current weather conditions for {district}")
+        
+        return {
+            "alert_id": f"{state.upper()[:2]}_{district.upper()[:3]}_001_{datetime.now().strftime('%Y%m%d')}",
+            "timestamp": datetime.now().isoformat() + "Z",
+            "location": {
+                "village": village_name,
+                "district": district,
+                "state": state.capitalize(),
+                "coordinates": location_coords
+            },
+            "crop": {
+                "name": regional_crop,
+                "stage": crop_stage,
+                "planted_estimate": "2025-06-15"
+            },
+            "alert": {
+                "type": alert_type,
+                "urgency": urgency,
+                "message": alert_message,
+                "action_items": action_items,
+                "valid_until": (datetime.now() + timedelta(days=3)).isoformat() + "Z"
+            },
+            "weather": real_weather,
+            "data_source": "open_meteo_api"  
+        }
+    
+    except Exception as e:
+        logger.error(f"Error generating dynamic alert for {district}, {state}: {e}")
+        raise Exception(f"Failed to generate weather alert for {district}: {str(e)}")
+
+
+@app.get("/")
+async def root():
+    return {"message": "MCP Weather Server is running"}
+
+@app.get("/api/health")
+async def health_check():
+    return {"status": "healthy", "message": "API is working"}
+
+#  workflow endpoint for frontend
+@app.post("/api/run-workflow")
+async def run_workflow(request: WorkflowRequest):
+    logger.info(f"Received workflow request: {request.state}, {request.district}")
+    
+    # Initialize variables
+    sample_alert = None
+    csv_content = ""
+    
+    try:
+        # Create comprehensive workflow response
+        workflow_results = []
+        
+        # Add workflow header
+        workflow_results.append(f"Workflow for {request.district}, {request.state}")
+        workflow_results.append("=" * 50)
+        
+        # weather data collection
+        workflow_results.append("\n🌤️ Weather Data Collection")
+        workflow_results.append("-" * 30)
+        workflow_results.append("📡 Fetching real-time weather data...")
+        
+        try:
+            sample_alert = await generate_dynamic_alert(request.district, request.state)
+            
+            workflow_results.append("✅ Current weather data retrieved from Open-Meteo API")
+            workflow_results.append("✅ 7-day forecast collected")
+            workflow_results.append("✅ Agricultural indices calculated")
+            
+        except Exception as weather_error:
+            logger.error(f"Weather data error: {weather_error}")
+            workflow_results.append(f"❌ Weather data collection failed: {str(weather_error)}")
+            return {
+                "message": "\n".join(workflow_results),
+                "status": "error",
+                "csv": "",
+                "error": f"Unable to retrieve weather data: {str(weather_error)}"
+            }
+        
+        if not sample_alert:
+            return {
+                "message": "Failed to generate alert data",
+                "status": "error", 
+                "csv": "",
+                "error": "Alert generation failed"
+            }
+        
+        # Alert generation
+        workflow_results.append("\n🚨 Alert Generation")
+        workflow_results.append("-" * 30)
+        workflow_results.append("✅ Weather alerts generated")
+        workflow_results.append(f"   - Data Source: {sample_alert.get('data_source', 'API')}")
+        workflow_results.append(f"   - Alert Type: {sample_alert['alert']['type']}")
+        workflow_results.append(f"   - Severity: {sample_alert['alert']['urgency']}")
+        workflow_results.append(f"   - Village: {sample_alert['location']['village']}")
+        workflow_results.append(f"   - Coordinates: {sample_alert['location']['coordinates']}")
+        workflow_results.append(f"   - Crop: {sample_alert['crop']['name']} ({sample_alert['crop']['stage']})")
+        workflow_results.append(f"   - Temperature: {sample_alert['weather']['temperature']}")
+        workflow_results.append(f"   - Humidity: {sample_alert['weather']['humidity']}")
+        workflow_results.append(f"   - Expected Rainfall: {sample_alert['weather']['expected_rainfall']}")
+        workflow_results.append(f"   - Rain Probability: {sample_alert['weather']['rain_probability']}%")
+    
+        # WhatsApp Agent Response
+        workflow_results.append("\n📱 WhatsApp Agent Response")
+        workflow_results.append("-" * 30)
+        try:
+            whatsapp_message = whatsapp_agent.create_whatsapp_message(sample_alert)
+            workflow_results.append(f"✅ Message created successfully")
+            workflow_results.append(f"Text: {whatsapp_message.get('text', 'N/A')}")
+            if 'buttons' in whatsapp_message:
+                workflow_results.append(f"Buttons: {len(whatsapp_message['buttons'])} button(s)")
+        except Exception as e:
+            workflow_results.append(f"❌ Error: {str(e)}")
+        
+        # SMS Agent Response
+        workflow_results.append("\n📱 SMS Agent Response")
+        workflow_results.append("-" * 30)
+        try:
+            sms_message = sms_agent.create_sms_message(sample_alert)
+            workflow_results.append(f"✅ SMS created successfully")
+            workflow_results.append(f"Content: {str(sms_message)}")
+        except Exception as e:
+            workflow_results.append(f"❌ Error: {str(e)}")
+        
+        # USSD Agent Response
+        workflow_results.append("\n📞 USSD Agent Response")
+        workflow_results.append("-" * 30)
+        try:
+            ussd_menu = ussd_agent.create_ussd_menu(sample_alert)
+            workflow_results.append(f"✅ USSD menu created successfully")
+            workflow_results.append(f"Menu: {str(ussd_menu)}")
+        except Exception as e:
+            workflow_results.append(f"❌ Error: {str(e)}")
+        
+        # IVR Agent Response
+        workflow_results.append("\n🎙️ IVR Agent Response")
+        workflow_results.append("-" * 30)
+        try:
+            ivr_script = ivr_agent.create_ivr_script(sample_alert)
+            workflow_results.append(f"✅ IVR script created successfully")
+            workflow_results.append(f"Script: {str(ivr_script)}")
+        except Exception as e:
+            workflow_results.append(f"❌ Error: {str(e)}")
+        
+        # Telegram Agent Response
+        workflow_results.append("\n🤖 Telegram Agent Response")
+        workflow_results.append("-" * 30)
+        try:
+            telegram_message = telegram_agent.create_telegram_message(sample_alert)
+            workflow_results.append(f"✅ Telegram message created successfully")
+            workflow_results.append(f"Content: {str(telegram_message)}")
+        except Exception as e:
+            workflow_results.append(f"❌ Error: {str(e)}")
+        
+        # Summary
+        workflow_results.append("\n✅ Workflow Summary")
+        workflow_results.append("-" * 30)
+        workflow_results.append("Workflow execution completed with REAL weather data")
+        workflow_results.append(f"Location: {request.district}, {request.state}")
+        workflow_results.append(f"Weather Source: Open-Meteo API")
+        workflow_results.append(f"Timestamp: {datetime.now().strftime('%Y-%m-%d %H:%M:%S')}")
+        
+        # Join all results into a single formatted string
+        formatted_output = "\n".join(workflow_results)
+
+        # Generate CSV 
+        try:
+            csv_buffer = StringIO()
+            writer = csv.writer(csv_buffer)
+            
+            # Write headers
+            headers = ["weather data", "whatsapp", "sms", "ussd", "ivr", "telegram"]
+            writer.writerow(headers)
+            
+            # Prepare weather data as a single string with line breaks
+            weather_info = "\n".join([
+                f"   - Data Source: {sample_alert.get('data_source', 'API')}",
+                f"   - Alert Type: {sample_alert['alert']['type']}",
+                f"   - Severity: {sample_alert['alert']['urgency']}",
+                f"   - Village: {sample_alert['location']['village']}",
+                f"   - Coordinates: {sample_alert['location']['coordinates']}",
+                f"   - Crop: {sample_alert['crop']['name']} ({sample_alert['crop']['stage']})",
+                f"   - Temperature: {sample_alert['weather']['temperature']}",
+                f"   - Humidity: {sample_alert['weather']['humidity']}",
+                f"   - Expected Rainfall: {sample_alert['weather']['expected_rainfall']}",
+                f"   - Rain Probability: {sample_alert['weather']['rain_probability']}%"
+            ])
+            
+            weather_data = [weather_info]
+            
+            # Extract agent outputs only (no status messages)
+            whatsapp_data = []
+            sms_data = []
+            ussd_data = []
+            ivr_data = []
+            telegram_data = []
+            
+            # Get WhatsApp message
+            try:
+                whatsapp_message = whatsapp_agent.create_whatsapp_message(sample_alert)
+                whatsapp_text = whatsapp_message.get('text', 'N/A')
+                whatsapp_data.append(whatsapp_text)
+                if 'buttons' in whatsapp_message and whatsapp_message['buttons']:
+                    whatsapp_data.append(f"Buttons: {whatsapp_message['buttons']}")
+            except Exception as e:
+                whatsapp_data.append(f"Error: {str(e)}")
+            
+            # Get SMS message
+            try:
+                sms_message = sms_agent.create_sms_message(sample_alert)
+                sms_data.append(str(sms_message))
+            except Exception as e:
+                sms_data.append(f"Error: {str(e)}")
+            
+            # Get USSD menu
+            try:
+                ussd_menu = ussd_agent.create_ussd_menu(sample_alert)
+                ussd_data.append(str(ussd_menu))
+            except Exception as e:
+                ussd_data.append(f"Error: {str(e)}")
+            
+            # Get IVR script
+            try:
+                ivr_script = ivr_agent.create_ivr_script(sample_alert)
+                ivr_data.append(str(ivr_script))
+            except Exception as e:
+                ivr_data.append(f"Error: {str(e)}")
+            
+            # Get Telegram message
+            try:
+                telegram_message = telegram_agent.create_telegram_message(sample_alert)
+                telegram_data.append(str(telegram_message))
+            except Exception as e:
+                telegram_data.append(f"Error: {str(e)}")
+            
+            # Find the maximum number of rows needed
+            max_rows = max(
+                len(weather_data),
+                len(whatsapp_data) if whatsapp_data else 1,
+                len(sms_data) if sms_data else 1,
+                len(ussd_data) if ussd_data else 1,
+                len(ivr_data) if ivr_data else 1,
+                len(telegram_data) if telegram_data else 1
+            )
+            
+            # Write data rows
+            for i in range(max_rows):
+                row = [
+                    weather_data[i] if i < len(weather_data) else "",
+                    whatsapp_data[i] if i < len(whatsapp_data) else "",
+                    sms_data[i] if i < len(sms_data) else "",
+                    ussd_data[i] if i < len(ussd_data) else "",
+                    ivr_data[i] if i < len(ivr_data) else "",
+                    telegram_data[i] if i < len(telegram_data) else ""
+                ]
+                writer.writerow(row)
+
+            csv_content = csv_buffer.getvalue()
+            logger.info("CSV content generated successfully")
+            
+        except Exception as csv_error:
+            logger.error(f"Error generating CSV: {csv_error}")
+            csv_content = f"Error generating CSV: {str(csv_error)}"
+        
+        logger.info(f"Successfully completed workflow for {request.district}, {request.state}")
+        return {
+            "message": formatted_output,
+            "status": "success",
+            "csv": csv_content,
+            "raw_data": {
+                "state": request.state,
+                "district": request.district,
+                "alert_data": sample_alert
+            }
+        }
+        
+    except Exception as e:
+        logger.exception(f"Error in workflow for {request.district}, {request.state}")
+        return {
+            "message": f"Error running workflow: {str(e)}",
+            "status": "error",
+            "csv": "",
+            "error": str(e)
+        }
+
+
+@app.post("/mcp")
+async def mcp_endpoint(request: MCPRequest):
+    logger.info(f"Received request for tool: {request.tool}")
+    tool_config = get_tool_config(request.tool)
+
+    if not tool_config:
+        logger.error(f"Tool not found: {request.tool}")
+        raise HTTPException(status_code=404, detail="Tool not found")
+
+    try:
+        if tool_config["module"] == "open_meteo":
+            result = await getattr(open_meteo, request.tool)(**request.parameters)
+        elif tool_config["module"] == "tomorrow_io":
+            api_key = config.get("TOMORROW_IO_API_KEY")
+            result = await getattr(tomorrow_io, request.tool)(**request.parameters, api_key=api_key)
+        elif tool_config["module"] == "google_weather":
+            api_key = config.get("GOOGLE_WEATHER_API_KEY")
+            result = await getattr(google_weather, request.tool)(**request.parameters, api_key=api_key)
+        elif tool_config["module"] == "openweathermap":
+            api_key = config.get("OPENWEATHERMAP_API_KEY")
+            result = await getattr(openweathermap, request.tool)(**request.parameters, api_key=api_key)
+        elif tool_config["module"] == "accuweather":
+            api_key = config.get("ACCUWEATHER_API_KEY")
+            result = await getattr(accuweather, request.tool)(**request.parameters, api_key=api_key)
+        elif tool_config["module"] == "openai_llm":
+            api_key = config.get("OPENAI_API_KEY")
+            result = await getattr(openai_llm, request.tool)(**request.parameters, api_key=api_key)
+        elif tool_config["module"] == "geographic_tools":
+            result = await getattr(geographic_tools, request.tool)(**request.parameters)
+        elif tool_config["module"] == "crop_calendar_tools":
+            result = await getattr(crop_calendar_tools, request.tool)(**request.parameters)
+        elif tool_config["module"] == "alert_generation_tools":
+            api_key = config.get("OPENAI_API_KEY")
+            result = await getattr(alert_generation_tools, request.tool)(**request.parameters, api_key=api_key)
+        else:
+            raise HTTPException(status_code=500, detail="Invalid tool module")
+
+        logger.info(f"Successfully executed tool: {request.tool}")
+        return result
+    except Exception as e:
+        logger.exception(f"Error executing tool: {request.tool}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@app.post("/a2a/sms")
+async def a2a_sms_endpoint(request: AlertRequest):
+    return {"message": sms_agent.create_sms_message(request.alert_json)}
+
+@app.post("/a2a/whatsapp")
+async def a2a_whatsapp_endpoint(request: AlertRequest):
+    return whatsapp_agent.create_whatsapp_message(request.alert_json)
+
+@app.post("/a2a/ussd")
+async def a2a_ussd_endpoint(request: AlertRequest):
+    return {"menu": ussd_agent.create_ussd_menu(request.alert_json)}
+
+@app.post("/a2a/ivr")
+async def a2a_ivr_endpoint(request: AlertRequest):
+    return {"script": ivr_agent.create_ivr_script(request.alert_json)}
+
+@app.post("/a2a/telegram")
+async def a2a_telegram_endpoint(request: AlertRequest):
+    return telegram_agent.create_telegram_message(request.alert_json)
+
+
+# for smithery + context7
+
+@app.post("/mcp")
+async def mcp_rpc_handler(request: dict):
+    method = request.get("method")
+    params = request.get("params", {})
+    tool_name = params.get("tool_name")
+    arguments = params.get("arguments", {})
+    req_id = request.get("id")
+
+    # Handle run_workflow tool
+    if method == "call_tool" and tool_name == "run_workflow":
+        state = arguments.get("state")
+        district = arguments.get("district")
+        result = await run_workflow(WorkflowRequest(state=state, district=district))
+        return {"jsonrpc": "2.0", "result": result, "id": req_id}
+
+    # Handle other tools dynamically via your tool config
+    if method == "call_tool":
+        try:
+            result = await mcp_endpoint(MCPRequest(tool=tool_name, parameters=arguments))
+            return {"jsonrpc": "2.0", "result": result, "id": req_id}
+        except Exception as e:
+            return {"jsonrpc": "2.0", "error": {"code": -32000, "message": str(e)}, "id": req_id}
+
+    return {"jsonrpc": "2.0", "error": {"code": -32601, "message": "Unknown method"}, "id": req_id}
+
+
+if __name__ == "__main__":
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=8000)

tools/accuweather.py

@@ -0,0 +1,22 @@
+import os
+import httpx
+from fastapi import HTTPException
+
+API_KEY = os.getenv("ACCUWEATHER_API_KEY")
+BASE_URL = "http://dataservice.accuweather.com/currentconditions/v1"
+
+async def get_accuweather_current_conditions(location_key: str, api_key: str):
+    if not api_key:
+        raise HTTPException(status_code=500, detail="AccuWeather API key not configured")
+
+    params = {
+        "apikey": api_key,
+    }
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(f"{BASE_URL}/{location_key}", params=params)
+
+    if response.status_code != 200:
+        raise HTTPException(status_code=response.status_code, detail="Error fetching data from AccuWeather")
+
+    return response.json()

tools/alert_generation_tools.py

@@ -0,0 +1,21 @@
+"""
+This module contains tools for alert generation.
+"""
+from . import openai_llm
+
+async def generate_weather_alert(crop: str, weather_data: dict, growth_stage: str, api_key: str, latitude: float, longitude: float):
+    """
+    Generates a weather alert using an LLM.
+    """
+    prompt = f"Generate a weather alert for {crop} at the {growth_stage} stage. Weather data: {weather_data}"
+    response = await openai_llm.predict_weather_alert(latitude=latitude, longitude=longitude, api_key=api_key)
+    return response
+
+async def prioritize_alerts(alerts_list: list, urgency_factors: dict):
+    """
+    Prioritizes a list of alerts based on urgency factors.
+    """
+    # Mock implementation
+    for alert in alerts_list:
+        alert["urgency"] = urgency_factors.get(alert["crop"], 0)
+    return sorted(alerts_list, key=lambda x: x["urgency"], reverse=True)

tools/crop_calendar_tools.py

@@ -0,0 +1,227 @@
+"""
+This module contains tools for crop calendar operations.
+"""
+from datetime import date
+
+CROP_CALENDAR = {
+    "rice": {
+        "season": "Kharif",
+        "planting": "June-July",
+        "harvesting": "October-November",
+        "stages": [
+            "Nursery/Seedling", "Transplanting", "Vegetative", "Tillering",
+            "Panicle Initiation", "Flowering", "Milk/Dough", "Maturity", "Harvesting"
+        ]
+    },
+    "wheat": {
+        "season": "Rabi",
+        "planting": "November-December",
+        "harvesting": "March-April",
+        "stages": [
+            "Sowing", "Germination", "Tillering", "Jointing", "Booting",
+            "Heading", "Flowering", "Grain Filling", "Maturity", "Harvesting"
+        ]
+    },
+    "maize": {
+        "season": "Kharif/Zaid",
+        "planting": "June-July / March-April",
+        "harvesting": "September-October / June",
+        "stages": [
+            "Sowing", "Emergence", "Vegetative", "Tasseling", "Silking",
+            "Grain Filling", "Maturity", "Harvesting"
+        ]
+    },
+    "barley": {
+        "season": "Rabi",
+        "planting": "November",
+        "harvesting": "March-April",
+        "stages": [
+            "Sowing", "Germination", "Tillering", "Jointing", "Booting",
+            "Heading", "Flowering", "Grain Filling", "Maturity", "Harvesting"
+        ]
+    },
+    "gram": {
+        "season": "Rabi",
+        "planting": "October-November",
+        "harvesting": "March-April",
+        "stages": [
+            "Sowing", "Germination", "Vegetative", "Flowering", "Pod Formation",
+            "Pod Filling", "Maturity", "Harvesting"
+        ]
+    },
+    "lentil": {
+        "season": "Rabi",
+        "planting": "October-November",
+        "harvesting": "March-April",
+        "stages": [
+            "Sowing", "Germination", "Vegetative", "Flowering", "Pod Formation",
+            "Pod Filling", "Maturity", "Harvesting"
+        ]
+    },
+    "pea": {
+        "season": "Rabi",
+        "planting": "October-November",
+        "harvesting": "February-March",
+        "stages": [
+            "Sowing", "Germination", "Vegetative", "Flowering", "Pod Formation",
+            "Pod Filling", "Maturity", "Harvesting"
+        ]
+    },
+    "mustard": {
+        "season": "Rabi",
+        "planting": "October-November",
+        "harvesting": "February-March",
+        "stages": [
+            "Sowing", "Germination", "Rosette", "Stem Elongation", "Flowering",
+            "Pod Formation", "Pod Filling", "Maturity", "Harvesting"
+        ]
+    },
+    "linseed": {
+        "season": "Rabi",
+        "planting": "October-November",
+        "harvesting": "March-April",
+        "stages": [
+            "Sowing", "Germination", "Vegetative", "Flowering", "Capsule Formation",
+            "Seed Filling", "Maturity", "Harvesting"
+        ]
+    },
+    "potato": {
+        "season": "Rabi",
+        "planting": "October-November",
+        "harvesting": "February-March",
+        "stages": [
+            "Planting", "Sprouting", "Vegetative", "Tuber Initiation", "Tuber Bulking",
+            "Maturity", "Harvesting"
+        ]
+    },
+    "arhar": {
+        "season": "Kharif",
+        "planting": "June-July",
+        "harvesting": "November-December",
+        "stages": [
+            "Sowing", "Germination", "Vegetative", "Flowering", "Pod Formation",
+            "Pod Filling", "Maturity", "Harvesting"
+        ]
+    },
+    "moong": {
+        "season": "Kharif/Zaid",
+        "planting": "June-July / March-April",
+        "harvesting": "September-October / June",
+        "stages": [
+            "Sowing", "Germination", "Vegetative", "Flowering", "Pod Formation",
+            "Pod Filling", "Maturity", "Harvesting"
+        ]
+    },
+    "urd": {
+        "season": "Kharif/Zaid",
+        "planting": "June-July / March-April",
+        "harvesting": "September-October / June",
+        "stages": [
+            "Sowing", "Germination", "Vegetative", "Flowering", "Pod Formation",
+            "Pod Filling", "Maturity", "Harvesting"
+        ]
+    },
+    "jowar": {
+        "season": "Kharif",
+        "planting": "June-July",
+        "harvesting": "September-October",
+        "stages": [
+            "Sowing", "Germination", "Vegetative", "Booting", "Flowering",
+            "Grain Filling", "Maturity", "Harvesting"
+        ]
+    },
+    "bajra": {
+        "season": "Kharif",
+        "planting": "June-July",
+        "harvesting": "September-October",
+        "stages": [
+            "Sowing", "Germination", "Vegetative", "Booting", "Flowering",
+            "Grain Filling", "Maturity", "Harvesting"
+        ]
+    },
+    "groundnut": {
+        "season": "Kharif",
+        "planting": "June-July",
+        "harvesting": "September-October",
+        "stages": [
+            "Sowing", "Germination", "Vegetative", "Flowering", "Pegging",
+            "Pod Formation", "Pod Filling", "Maturity", "Harvesting"
+        ]
+    },
+    "soybean": {
+        "season": "Kharif",
+        "planting": "June-July",
+        "harvesting": "September-October",
+        "stages": [
+            "Sowing", "Germination", "Vegetative", "Flowering", "Pod Formation",
+            "Pod Filling", "Maturity", "Harvesting"
+        ]
+    },
+    "watermelon": {
+        "season": "Zaid",
+        "planting": "March-April",
+        "harvesting": "May-June",
+        "stages": [
+            "Sowing", "Germination", "Vegetative", "Flowering", "Fruit Setting",
+            "Fruit Development", "Maturity", "Harvesting"
+        ]
+    },
+    "cucumber": {
+        "season": "Zaid",
+        "planting": "March-April",
+        "harvesting": "May-June",
+        "stages": [
+            "Sowing", "Germination", "Vegetative", "Flowering", "Fruit Setting",
+            "Fruit Development", "Maturity", "Harvesting"
+        ]
+    }
+}
+
+
+from datetime import date
+from .geographic_tools import BIHAR_DATA
+
+async def get_crop_calendar(region: str, crop_type: str = None):
+    if region.lower() == 'bihar':
+        if crop_type:
+            crop = crop_type.lower()
+            if crop in CROP_CALENDAR:
+                return {**CROP_CALENDAR[crop], "crop": crop}
+            else:
+                return {"error": "Crop not found in Bihar"}
+        return {
+            "crops": list(CROP_CALENDAR.keys()),
+            "districts": list(BIHAR_DATA.keys())
+        }
+    return {"error": "Region not found"}
+
+async def get_prominent_crops(region: str, season: str):
+    if region.lower() == 'bihar':
+        season = season.lower()
+        crops = [crop for crop, data in CROP_CALENDAR.items() if season in data["season"].lower()]
+        if crops:
+            return {"crops": crops}
+        else:
+            return {"error": "No crops found for this season in Bihar"}
+    return {"error": "Region or season not found"}
+
+async def estimate_crop_stage(crop: str, plant_date: str, current_date: str):
+    plant_date = date.fromisoformat(plant_date)
+    current_date = date.fromisoformat(current_date)
+    days_since_planting = (current_date - plant_date).days
+
+    crop = crop.lower()
+    if crop in CROP_CALENDAR:
+        stages = CROP_CALENDAR[crop]["stages"]
+        # Estimate total duration (in days) for each crop (approximate, can be refined)
+        crop_durations = {
+            "rice": 120, "wheat": 120, "maize": 110, "barley": 110, "gram": 110,
+            "lentil": 110, "pea": 100, "mustard": 110, "linseed": 110, "potato": 100,
+            "arhar": 150, "moong": 70, "urd": 70, "jowar": 100, "bajra": 90,
+            "groundnut": 110, "soybean": 100, "watermelon": 80, "cucumber": 70
+        }
+        total_duration = crop_durations.get(crop, 100)
+        stage_length = total_duration // len(stages)
+        stage_index = min(days_since_planting // stage_length, len(stages) - 1)
+        return {"stage": stages[stage_index]}
+    return {"error": "Crop not found"}

tools/google_weather.py

@@ -0,0 +1,24 @@
+import os
+import httpx
+from fastapi import HTTPException
+
+API_KEY = os.getenv("GOOGLE_WEATHER_API_KEY")
+BASE_URL = "https://weather.googleapis.com/v1/currentConditions:lookup"
+
+async def get_google_weather_current_conditions(latitude: float, longitude: float, api_key: str):
+    if not api_key:
+        raise HTTPException(status_code=500, detail="Google Weather API key not configured")
+
+    params = {
+        "key": api_key,
+        "location.latitude": latitude,
+        "location.longitude": longitude
+    }
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(BASE_URL, params=params)
+
+    if response.status_code != 200:
+        raise HTTPException(status_code=response.status_code, detail="Error fetching data from Google Weather API")
+
+    return response.json()

tools/open_meteo.py

@@ -0,0 +1,67 @@
+import httpx
+from fastapi import HTTPException
+
+BASE_URL = "https://api.open-meteo.com/v1/forecast"
+
+async def get_weather_forecast(latitude: float, longitude: float, days: int = 7, include_hourly: bool = False):
+    params = {
+        "latitude": latitude,
+        "longitude": longitude,
+        "daily": "weathercode,temperature_2m_max,temperature_2m_min,precipitation_sum,windspeed_10m_max",
+        "forecast_days": days,
+    }
+    if include_hourly:
+        params["hourly"] = "temperature_2m,relativehumidity_2m,weathercode"
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(BASE_URL, params=params)
+
+    if response.status_code != 200:
+        raise HTTPException(status_code=response.status_code, detail="Error fetching data from OpenMeteo")
+
+    return response.json()
+
+async def analyze_weather_trends(latitude: float, longitude: float, period: str):
+    """
+    Analyzes weather trends for a given location and period.
+    """
+    # This is a mock implementation. A real implementation would perform a more complex analysis.
+    if period == "7-day":
+        return {"trend": "clear", "confidence": 0.8}
+    elif period == "30-day":
+        return {"trend": "mixed", "confidence": 0.6}
+    else:
+        return {"error": "Invalid period"}
+
+async def get_current_weather(latitude: float, longitude: float):
+    params = {
+        "latitude": latitude,
+        "longitude": longitude,
+        "current_weather": True,
+    }
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(BASE_URL, params=params)
+
+    if response.status_code != 200:
+        raise HTTPException(status_code=response.status_code, detail="Error fetching data from OpenMeteo")
+
+    return response.json()
+
+async def get_historical_weather(latitude: float, longitude: float, start_date: str, end_date: str):
+    params = {
+        "latitude": latitude,
+        "longitude": longitude,
+        "start_date": start_date,
+        "end_date": end_date,
+        "daily": "weathercode,temperature_2m_max,temperature_2m_min,precipitation_sum",
+    }
+    historical_url = "https://archive-api.open-meteo.com/v1/era5"
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(historical_url, params=params)
+
+    if response.status_code != 200:
+        raise HTTPException(status_code=response.status_code, detail="Error fetching data from OpenMeteo")
+
+    return response.json()

tools/openai_llm.py

@@ -0,0 +1,61 @@
+import os
+import json
+from fastapi import HTTPException
+from openai import OpenAI
+from . import open_meteo
+
+async def predict_weather_alert(latitude: float, longitude: float, api_key: str):
+    """
+    Predicts weather alerts for a given location and crops using an OpenAI LLM.
+
+    Args:
+        latitude: The latitude of the location.
+        longitude: The longitude of the location.
+        crops: A list of crops to consider for the prediction.
+
+    Returns:
+        A dictionary containing the predicted weather alert.
+    """
+    try:
+        weather_data = await open_meteo.get_weather_forecast(latitude, longitude)
+    except HTTPException as e:
+        raise HTTPException(status_code=e.status_code, detail=f"Error getting weather data: {e.detail}")
+
+    try:
+        client = OpenAI(api_key=api_key)
+        prompt = f"""
+        Given the following weather data for a location:
+        {weather_data}
+
+        Please predict any potential weather alerts for these crops in the next 7 days.
+        For the given region, consider what crops are possible to grow and their sensitivity to weather conditions.
+        Include the following details in your response:
+        - Expected weather conditions (e.g., temperature, precipitation, wind speed)
+        - Potential weather alerts (e.g., frost, drought, heavy rainfall)
+        - Impact on crops (e.g., growth, yield, disease risk)
+        - Recommended actions for farmers (e.g., irrigation, protection measures)
+        - Any other relevant information that could help farmers prepare for the weather conditions.
+        Provide a summary of the potential impact on the crops and any recommended actions.
+        Format your response as a JSON object with the following structure:
+        {{
+            "alert": "Description of the alert",
+            "impact": "Description of the impact on crops",
+            "recommendations": "Recommended actions for farmers"
+        }}
+        Do not include any additional text outside of the JSON object. no line changes or markdown formatting.
+        """
+
+        response = client.chat.completions.create(
+            model="gpt-4o-mini",
+            messages=[
+                {"role": "system", "content": "You are a helpful assistant that predicts weather alerts for farmers."},
+                {"role": "user", "content": prompt}
+            ],
+            response_format= { "type": "json_object" }
+        )
+
+        response = response.choices[0].message.content
+        if response:
+            return json.loads(response)
+    except Exception as e:
+        raise HTTPException(status_code=500, detail=f"Error getting prediction from OpenAI: {str(e)}")

tools/openweathermap.py

@@ -0,0 +1,23 @@
+import os
+import httpx
+from fastapi import HTTPException
+
+BASE_URL = "https://api.openweathermap.org/data/2.5/weather"
+
+async def get_openweathermap_weather(lat: float, lon: float, api_key: str):
+    if not api_key:
+        raise HTTPException(status_code=500, detail="OpenWeatherMap API key not configured")
+
+    params = {
+        "lat": lat,
+        "lon": lon,
+        "appid": api_key,
+    }
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(BASE_URL, params=params)
+
+    if response.status_code != 200:
+        raise HTTPException(status_code=response.status_code, detail="Error fetching data from OpenWeatherMap")
+
+    return response.json()

tools/tomorrow_io.py

@@ -0,0 +1,43 @@
+import os
+import httpx
+from fastapi import HTTPException
+
+API_KEY = os.getenv("TOMORROW_IO_API_KEY")
+BASE_URL = "https://api.tomorrow.io/v4"
+
+async def get_tomorrow_weather(location: str, fields: str = "temperature,weatherCode", timesteps: str = "1h", units: str = "metric"):
+    if not API_KEY:
+        raise HTTPException(status_code=500, detail="Tomorrow.io API key not configured")
+
+    params = {
+        "location": location,
+        "fields": fields.split(','),
+        "timesteps": timesteps.split(','),
+        "units": units,
+        "apikey": API_KEY,
+    }
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(f"{BASE_URL}/weather/forecast", params=params)
+
+    if response.status_code != 200:
+        raise HTTPException(status_code=response.status_code, detail="Error fetching data from Tomorrow.io")
+
+    return response.json()
+
+async def get_weather_alerts(location: str):
+    if not API_KEY:
+        raise HTTPException(status_code=500, detail="Tomorrow.io API key not configured")
+
+    params = {
+        "location": location,
+        "apikey": API_KEY,
+    }
+
+    async with httpx.AsyncClient() as client:
+        response = await client.get(f"{BASE_URL}/weather/alerts", params=params)
+
+    if response.status_code != 200:
+        raise HTTPException(status_code=response.status_code, detail="Error fetching data from Tomorrow.io")
+
+    return response.json()

utils/weather_utils.py

@@ -0,0 +1,23 @@
+TOOL_CONFIG = {
+    "get_weather_forecast": {"module": "open_meteo"},
+    "get_current_weather": {"module": "open_meteo"},
+    "get_historical_weather": {"module": "open_meteo"},
+    "analyze_weather_trends": {"module": "open_meteo"},
+    "get_tomorrow_weather": {"module": "tomorrow_io"},
+    "get_weather_alerts": {"module": "tomorrow_io"},
+    "get_google_weather_current_conditions": {"module": "google_weather"},
+    "get_openweathermap_weather": {"module": "openweathermap"},
+    "get_accuweather_current_conditions": {"module": "accuweather"},
+    "predict_weather_alert": {"module": "openai_llm"},
+    "list_villages": {"module": "geographic_tools"},
+    "reverse_geocode": {"module": "geographic_tools"},
+    "get_administrative_bounds": {"module": "geographic_tools"},
+    "get_crop_calendar": {"module": "crop_calendar_tools"},
+    "get_prominent_crops": {"module": "crop_calendar_tools"},
+    "estimate_crop_stage": {"module": "crop_calendar_tools"},
+    "generate_weather_alert": {"module": "alert_generation_tools"},
+    "prioritize_alerts": {"module": "alert_generation_tools"},
+}
+
+def get_tool_config(tool_name: str):
+    return TOOL_CONFIG.get(tool_name)