Upload 31 files

.gitattributes

@@ -0,0 +1,7 @@
+models/market_model_corn.pkl filter=lfs diff=lfs merge=lfs -text
+models/market_model_rice.pkl filter=lfs diff=lfs merge=lfs -text
+models/market_model_soybean.pkl filter=lfs diff=lfs merge=lfs -text
+models/market_model_wheat.pkl filter=lfs diff=lfs merge=lfs -text
+models/rain_model.pkl filter=lfs diff=lfs merge=lfs -text
+models/sustainable_farming.db filter=lfs diff=lfs merge=lfs -text
+models/temp_model.pkl filter=lfs diff=lfs merge=lfs -text

models/central_coordinator.py

@@ -0,0 +1,204 @@
+import joblib
+from Models.farmer_advisor import FarmerAdvisor
+from Models.market_Researcher import MarketResearcher
+from Models.weather_Analyst import WeatherAnalyst
+from Models.sustainability_Expert import SustainabilityExpert
+import matplotlib.pyplot as plt
+from Models import weather_api
+from Models.pest_disease_predictor import PestDiseasePredictor
+
+
+class CentralCoordinator:
+    def __init__(self):
+        db_path = "database/sustainable_farming.db"
+        self.farmer_advisor = FarmerAdvisor(db_path=db_path)
+        self.market_researcher = MarketResearcher(db_path=db_path)
+        self.weather_analyst = WeatherAnalyst(db_path=db_path)
+        self.sustainability_expert = SustainabilityExpert(db_path=db_path)
+        self.pest_predictor = PestDiseasePredictor()
+
+    def generate_recommendation(self, soil_ph, soil_moisture, temperature, rainfall,
+                                fertilizer, pesticide, crop_yield, city_name=None):
+        warnings = []
+        # If city_name is provided, fetch real-time weather
+        if city_name:
+            try:
+                weather = weather_api.get_current_weather(city_name)
+                temperature = weather['temperature']
+                rainfall = weather['rainfall']
+            except Exception as e:
+                warnings.append(f"Weather API error: {e}")
+
+        # 1. Recommend crop using FarmerAdvisor
+        crop = self.farmer_advisor.recommend(
+            soil_ph, soil_moisture, temperature, rainfall,
+            fertilizer, pesticide, crop_yield
+        )
+
+        # Pest/Disease prediction
+        pest_advice = self.pest_predictor.predict(
+            crop_type=crop,
+            soil_ph=soil_ph,
+            soil_moisture=soil_moisture,
+            temperature=temperature,
+            rainfall=rainfall
+        )
+
+        # 2. Prepare dummy input for MarketResearcher
+        market_features = {
+            'Demand_Index': 0.5,
+            'Supply_Index': 0.5,
+            'Competitor_Price_per_ton': 1000.0,
+            'Economic_Indicator': 0.8,
+            'Weather_Impact_Score': 0.7,
+            'Seasonal_Factor': 'Medium',
+            'Consumer_Trend_Index': 0.6
+        }
+
+        # 3. Market forecast for recommended crop
+        market_forecast = self.market_researcher.forecast(product=crop, input_features=market_features)
+        market_score = market_forecast[0] / 1000  # Normalize
+
+        # 4. Weather forecast
+        weather_forecast = self.weather_analyst.forecast(
+            soil_ph=soil_ph,
+            soil_moisture=soil_moisture,
+            fertilizer=fertilizer,
+            pesticide=pesticide
+        )
+        predicted_temp = weather_forecast['temperature'][0]
+        predicted_rain = weather_forecast['rainfall'][0]
+
+        # 5. Weather suitability score
+        weather_score = 1 - abs(predicted_temp - temperature) / 50 - abs(predicted_rain - rainfall) / 100
+        weather_score = max(0, round(weather_score, 2))
+
+        # 6. Get sustainability scores
+        scores = self.sustainability_expert.evaluate(
+            [crop],
+            soil_ph=soil_ph,
+            soil_moisture=soil_moisture,
+            rainfall=rainfall,
+            fertilizer=fertilizer,
+            pesticide=pesticide,
+            crop_yield=crop_yield
+        )
+
+        # Get the scores dictionary from the tuple returned by evaluate
+        sustainability_scores = scores[1]  # Dictionary with all scores
+
+        # 7. Final weighted score
+        final_score = (
+            0.25 * market_score +
+            0.20 * weather_score +
+            0.20 * sustainability_scores['sustainability'] +
+            0.15 * sustainability_scores['carbon'] +
+            0.10 * sustainability_scores['water'] +
+            0.10 * sustainability_scores['erosion']
+        )
+
+        # 8. Enhanced Weather Warnings
+        if city_name:
+            # General weather hazards
+            if temperature > 40:
+                warnings.append("Warning: High temperature detected! Crop stress and yield loss possible.")
+            if rainfall > 50:
+                warnings.append("Warning: Heavy rainfall detected! Risk of flooding and waterlogging.")
+            if temperature < 5:
+                warnings.append("Warning: Low temperature detected! Frost risk and stunted growth possible.")
+            if rainfall < 5:
+                warnings.append("Warning: Very low rainfall detected! Drought risk and irrigation needed.")
+            # Crop-specific suitability (example ranges, can be refined per crop)
+            crop_temp_ranges = {
+                'Wheat': (10, 25),
+                'Rice': (20, 35),
+                'Corn': (15, 35),
+                'Soybeans': (15, 30),
+                'Cotton': (20, 35)
+            }
+            crop_rain_ranges = {
+                'Wheat': (30, 90),
+                'Rice': (100, 200),
+                'Corn': (50, 120),
+                'Soybeans': (50, 100),
+                'Cotton': (50, 100)
+            }
+            temp_range = crop_temp_ranges.get(crop)
+            rain_range = crop_rain_ranges.get(crop)
+            if temp_range:
+                if not (temp_range[0] <= temperature <= temp_range[1]):
+                    warnings.append(f"Warning: Real-time temperature ({temperature}°C) is outside the optimal range for {crop} ({temp_range[0]}–{temp_range[1]}°C).")
+            if rain_range:
+                if not (rain_range[0] <= rainfall <= rain_range[1]):
+                    warnings.append(f"Warning: Real-time rainfall ({rainfall} mm) is outside the optimal range for {crop} ({rain_range[0]}–{rain_range[1]} mm).")
+            # Severe weather
+            if temperature > 45:
+                warnings.append("Severe Alert: Extreme heat! Crop failure likely.")
+            if temperature < 0:
+                warnings.append("Severe Alert: Freezing conditions! Crop loss likely.")
+            if rainfall > 100:
+                warnings.append("Severe Alert: Torrential rain! Flooding and root rot risk.")
+
+        result = {
+            'Recommended Crop': crop,
+            'Market Score': round(market_score, 2),
+            'Weather Suitability Score': weather_score,
+            'Sustainability Score': round(sustainability_scores['sustainability'], 2),
+            'Carbon Footprint Score': round(sustainability_scores['carbon'], 2),
+            'Water Score': round(sustainability_scores['water'], 2),
+            'Erosion Score': round(sustainability_scores['erosion'], 2),
+            'Final Score': round(final_score, 2),
+            'Predicted Temperature': round(predicted_temp, 2),
+            'Predicted Rainfall': round(predicted_rain, 2),
+            'Real-Time Temperature': round(temperature, 2) if city_name else None,
+            'Real-Time Rainfall': round(rainfall, 2) if city_name else None,
+            'Warnings': warnings,
+            'Pest/Disease Advice': pest_advice
+        }
+        return result
+
+    @staticmethod
+    def plot_scores(result):
+        # Extract relevant numeric scores
+        labels = []
+        values = []
+        for key in ['Market Score', 'Weather Suitability Score', 'Sustainability Score',
+                    'Carbon Footprint Score', 'Water Score', 'Erosion Score', 'Final Score']:
+            val = result.get(key)
+            if val is not None:
+                labels.append(key)
+                values.append(val)
+
+        # Plot
+        plt.figure(figsize=(10, 8))
+        colors = ['#4caf50', '#2196f3', '#ff9800', '#607d8b',
+                 '#00bcd4', '#795548', '#e91e63']
+        
+        # Create pie chart
+        plt.pie(values, labels=labels, colors=colors, autopct='%1.1f%%',
+                startangle=90, shadow=True)
+        plt.title('Crop Recommendation Score Distribution')
+        plt.axis('equal')  # Equal aspect ratio ensures that pie is drawn as a circle
+        plt.tight_layout()
+        plt.show()
+
+
+# Run it directly (for testing)
+if __name__ == "__main__":
+    coordinator = CentralCoordinator()
+    result = coordinator.generate_recommendation(
+        soil_ph=6.5,
+        soil_moisture=35,
+        temperature=27,
+        rainfall=60,
+        fertilizer=20,
+        pesticide=5,
+        crop_yield=3.5,
+        city_name="New York"
+    )
+
+    print("\n --- Final Recommendation ---")
+    for k, v in result.items():
+        print(f"{k}: {v}")
+
+    CentralCoordinator.plot_scores(result)

models/enhanced_pest_predictor.py

@@ -0,0 +1,419 @@
+import os
+import logging
+from typing import Dict, List, Optional, Tuple
+from datetime import datetime, timedelta
+import pandas as pd
+from dotenv import load_dotenv
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import torch
+import json
+
+# Load environment variables
+load_dotenv()
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+class EnhancedPestDiseasePredictor:
+    """
+    Enhanced pest and disease predictor using Llama 2 for intelligent analysis
+    """
+    
+    def __init__(self):
+        # Initialize Llama 2 model for pest/disease analysis
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model_name = "meta-llama/Llama-2-7b-chat-hf"
+        
+        try:
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            self.model = AutoModelForCausalLM.from_pretrained(
+                self.model_name,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                device_map="auto" if self.device == "cuda" else None
+            )
+            logger.info(f"Loaded Llama 2 model for pest prediction on {self.device}")
+        except Exception as e:
+            logger.warning(f"Could not load Llama 2 model: {e}. Using rule-based fallback.")
+            self.model = None
+            self.tokenizer = None
+        
+        # Pest and disease database
+        self.pest_database = self._load_pest_database()
+        self.disease_database = self._load_disease_database()
+    
+    def _load_pest_database(self) -> Dict:
+        """Load comprehensive pest database"""
+        return {
+            'wheat': {
+                'aphids': {
+                    'conditions': {'temp_range': (15, 25), 'humidity_range': (40, 80), 'rainfall_range': (20, 100)},
+                    'symptoms': 'Yellowing leaves, sticky honeydew, stunted growth',
+                    'treatment': 'Neem oil spray, beneficial insects, resistant varieties',
+                    'risk_factors': ['high_nitrogen', 'dense_planting', 'poor_air_circulation']
+                },
+                'rust': {
+                    'conditions': {'temp_range': (15, 25), 'humidity_range': (70, 95), 'rainfall_range': (50, 150)},
+                    'symptoms': 'Orange or brown pustules on leaves and stems',
+                    'treatment': 'Fungicide application, crop rotation, resistant varieties',
+                    'risk_factors': ['high_humidity', 'warm_temperatures', 'previous_infestation']
+                },
+                'armyworm': {
+                    'conditions': {'temp_range': (20, 30), 'humidity_range': (50, 90), 'rainfall_range': (30, 120)},
+                    'symptoms': 'Chewed leaves, defoliation, larvae visible',
+                    'treatment': 'Bacillus thuringiensis, pheromone traps, natural predators',
+                    'risk_factors': ['warm_weather', 'high_humidity', 'dense_vegetation']
+                }
+            },
+            'rice': {
+                'brown_planthopper': {
+                    'conditions': {'temp_range': (25, 35), 'humidity_range': (70, 95), 'rainfall_range': (100, 300)},
+                    'symptoms': 'Yellowing and wilting, honeydew secretion, sooty mold',
+                    'treatment': 'Systemic insecticides, resistant varieties, proper water management',
+                    'risk_factors': ['high_nitrogen', 'excessive_irrigation', 'dense_planting']
+                },
+                'bacterial_leaf_blight': {
+                    'conditions': {'temp_range': (25, 35), 'humidity_range': (80, 95), 'rainfall_range': (150, 400)},
+                    'symptoms': 'Yellow stripes on leaves, wilting, plant death',
+                    'treatment': 'Copper-based fungicides, resistant varieties, proper drainage',
+                    'risk_factors': ['high_humidity', 'warm_temperatures', 'poor_drainage']
+                },
+                'rice_blast': {
+                    'conditions': {'temp_range': (20, 30), 'humidity_range': (85, 95), 'rainfall_range': (100, 300)},
+                    'symptoms': 'Diamond-shaped lesions on leaves, neck rot, yield loss',
+                    'treatment': 'Fungicide application, resistant varieties, proper spacing',
+                    'risk_factors': ['high_humidity', 'cool_temperatures', 'excessive_nitrogen']
+                }
+            },
+            'corn': {
+                'corn_borer': {
+                    'conditions': {'temp_range': (20, 30), 'humidity_range': (50, 80), 'rainfall_range': (40, 120)},
+                    'symptoms': 'Holes in stalks, ear damage, reduced yield',
+                    'treatment': 'Bt corn varieties, beneficial insects, crop rotation',
+                    'risk_factors': ['warm_weather', 'dense_planting', 'previous_infestation']
+                },
+                'corn_earworm': {
+                    'conditions': {'temp_range': (25, 35), 'humidity_range': (60, 85), 'rainfall_range': (50, 150)},
+                    'symptoms': 'Damage to ears, frass in silk, reduced quality',
+                    'treatment': 'Insecticides, Bt varieties, pheromone traps',
+                    'risk_factors': ['warm_weather', 'high_humidity', 'late_planting']
+                },
+                'gray_leaf_spot': {
+                    'conditions': {'temp_range': (20, 30), 'humidity_range': (80, 95), 'rainfall_range': (80, 200)},
+                    'symptoms': 'Gray lesions on leaves, premature death',
+                    'treatment': 'Fungicide application, resistant varieties, crop rotation',
+                    'risk_factors': ['high_humidity', 'warm_temperatures', 'continuous_corn']
+                }
+            },
+            'tomato': {
+                'aphids': {
+                    'conditions': {'temp_range': (20, 30), 'humidity_range': (50, 80), 'rainfall_range': (30, 100)},
+                    'symptoms': 'Curled leaves, honeydew, virus transmission',
+                    'treatment': 'Neem oil, beneficial insects, reflective mulches',
+                    'risk_factors': ['high_nitrogen', 'dense_planting', 'poor_air_circulation']
+                },
+                'late_blight': {
+                    'conditions': {'temp_range': (15, 25), 'humidity_range': (85, 95), 'rainfall_range': (50, 150)},
+                    'symptoms': 'Water-soaked lesions, white mold, rapid spread',
+                    'treatment': 'Copper fungicides, resistant varieties, proper spacing',
+                    'risk_factors': ['high_humidity', 'cool_temperatures', 'poor_air_circulation']
+                },
+                'whitefly': {
+                    'conditions': {'temp_range': (25, 35), 'humidity_range': (40, 70), 'rainfall_range': (20, 80)},
+                    'symptoms': 'Yellowing leaves, honeydew, sooty mold',
+                    'treatment': 'Yellow sticky traps, beneficial insects, reflective mulches',
+                    'risk_factors': ['warm_weather', 'low_humidity', 'dense_planting']
+                }
+            }
+        }
+    
+    def _load_disease_database(self) -> Dict:
+        """Load comprehensive disease database"""
+        return {
+            'fungal_diseases': {
+                'powdery_mildew': {
+                    'conditions': {'temp_range': (15, 25), 'humidity_range': (70, 90), 'rainfall_range': (20, 100)},
+                    'symptoms': 'White powdery coating on leaves',
+                    'treatment': 'Sulfur fungicides, resistant varieties, proper spacing',
+                    'affected_crops': ['wheat', 'tomato', 'cucumber', 'grape']
+                },
+                'downy_mildew': {
+                    'conditions': {'temp_range': (10, 20), 'humidity_range': (85, 95), 'rainfall_range': (50, 200)},
+                    'symptoms': 'Yellow spots on upper leaves, white mold underneath',
+                    'treatment': 'Copper fungicides, resistant varieties, proper drainage',
+                    'affected_crops': ['lettuce', 'cucumber', 'grape', 'onion']
+                }
+            },
+            'bacterial_diseases': {
+                'bacterial_wilt': {
+                    'conditions': {'temp_range': (25, 35), 'humidity_range': (70, 90), 'rainfall_range': (50, 200)},
+                    'symptoms': 'Wilting, yellowing, plant death',
+                    'treatment': 'Copper-based bactericides, resistant varieties, crop rotation',
+                    'affected_crops': ['tomato', 'pepper', 'cucumber', 'eggplant']
+                }
+            },
+            'viral_diseases': {
+                'mosaic_viruses': {
+                    'conditions': {'temp_range': (20, 30), 'humidity_range': (50, 80), 'rainfall_range': (30, 120)},
+                    'symptoms': 'Mottled leaves, stunted growth, reduced yield',
+                    'treatment': 'Virus-free seeds, vector control, resistant varieties',
+                    'affected_crops': ['tomato', 'cucumber', 'tobacco', 'pepper']
+                }
+            }
+        }
+    
+    def predict_with_llama(self, crop_type: str, weather_data: Dict, soil_data: Dict) -> str:
+        """
+        Use Llama 2 to predict pest and disease risks
+        """
+        if not self.model or not self.tokenizer:
+            return self._rule_based_prediction(crop_type, weather_data, soil_data)
+        
+        try:
+            # Prepare context for Llama 2
+            context = f"""
+            As an agricultural pest and disease expert, analyze the following conditions for {crop_type} farming:
+            
+            Weather Conditions:
+            - Temperature: {weather_data.get('temperature', 'N/A')}°C
+            - Humidity: {weather_data.get('humidity', 'N/A')}%
+            - Rainfall: {weather_data.get('rainfall', 'N/A')} mm
+            - Wind Speed: {weather_data.get('wind_speed', 'N/A')} m/s
+            - Description: {weather_data.get('description', 'N/A')}
+            
+            Soil Conditions:
+            - pH: {soil_data.get('ph', 'N/A')}
+            - Moisture: {soil_data.get('moisture', 'N/A')}%
+            - Type: {soil_data.get('type', 'N/A')}
+            
+            Provide a comprehensive pest and disease risk assessment for {crop_type} including:
+            1. Most likely pests and diseases based on current conditions
+            2. Risk level (Low/Medium/High) for each threat
+            3. Specific symptoms to watch for
+            4. Recommended preventive measures
+            5. Treatment options if infestation occurs
+            6. Timing for monitoring and intervention
+            
+            Focus on practical, actionable advice for farmers.
+            """
+            
+            # Tokenize and generate response
+            inputs = self.tokenizer.encode(context, return_tensors="pt").to(self.device)
+            
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    inputs,
+                    max_length=inputs.shape[1] + 300,
+                    num_return_sequences=1,
+                    temperature=0.7,
+                    do_sample=True,
+                    pad_token_id=self.tokenizer.eos_token_id
+                )
+            
+            response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+            
+            # Extract the generated part
+            generated_text = response[len(context):].strip()
+            
+            return generated_text if generated_text else self._rule_based_prediction(crop_type, weather_data, soil_data)
+            
+        except Exception as e:
+            logger.error(f"Error in Llama 2 pest prediction: {e}")
+            return self._rule_based_prediction(crop_type, weather_data, soil_data)
+    
+    def predict(self, crop_type: str, soil_ph: float, soil_moisture: float, 
+                temperature: float, rainfall: float, additional_data: Dict = None) -> str:
+        """
+        Main prediction method that combines Llama 2 analysis with rule-based fallback
+        """
+        try:
+            # Prepare weather and soil data
+            weather_data = {
+                'temperature': temperature,
+                'humidity': 65.0,  # Default if not provided
+                'rainfall': rainfall,
+                'wind_speed': 3.0,  # Default if not provided
+                'description': 'partly cloudy'  # Default if not provided
+            }
+            
+            soil_data = {
+                'ph': soil_ph,
+                'moisture': soil_moisture,
+                'type': 'loamy'  # Default if not provided
+            }
+            
+            # Update with additional data if provided
+            if additional_data:
+                weather_data.update(additional_data.get('weather', {}))
+                soil_data.update(additional_data.get('soil', {}))
+            
+            # Get Llama 2 prediction
+            llama_prediction = self.predict_with_llama(crop_type, weather_data, soil_data)
+            
+            # Get rule-based risk assessment
+            risk_assessment = self._assess_risks(crop_type, weather_data, soil_data)
+            
+            # Combine predictions
+            combined_prediction = self._combine_predictions(llama_prediction, risk_assessment, crop_type)
+            
+            return combined_prediction
+            
+        except Exception as e:
+            logger.error(f"Error in pest prediction: {e}")
+            return self._rule_based_prediction(crop_type, weather_data, soil_data)
+    
+    def _assess_risks(self, crop_type: str, weather_data: Dict, soil_data: Dict) -> Dict:
+        """Assess pest and disease risks using rule-based approach"""
+        risks = {
+            'pests': [],
+            'diseases': [],
+            'overall_risk': 'low',
+            'recommendations': []
+        }
+        
+        temp = weather_data.get('temperature', 25)
+        humidity = weather_data.get('humidity', 65)
+        rainfall = weather_data.get('rainfall', 50)
+        soil_ph = soil_data.get('ph', 6.5)
+        soil_moisture = soil_data.get('moisture', 50)
+        
+        crop_lower = crop_type.lower()
+        
+        # Check for specific pests based on crop type
+        if crop_lower in self.pest_database:
+            for pest_name, pest_info in self.pest_database[crop_lower].items():
+                conditions = pest_info['conditions']
+                
+                # Check temperature conditions
+                temp_ok = conditions['temp_range'][0] <= temp <= conditions['temp_range'][1]
+                humidity_ok = conditions['humidity_range'][0] <= humidity <= conditions['humidity_range'][1]
+                rainfall_ok = conditions['rainfall_range'][0] <= rainfall <= conditions['rainfall_range'][1]
+                
+                if temp_ok and humidity_ok and rainfall_ok:
+                    risks['pests'].append({
+                        'name': pest_name,
+                        'risk_level': 'high',
+                        'symptoms': pest_info['symptoms'],
+                        'treatment': pest_info['treatment']
+                    })
+                elif any([temp_ok, humidity_ok, rainfall_ok]):
+                    risks['pests'].append({
+                        'name': pest_name,
+                        'risk_level': 'medium',
+                        'symptoms': pest_info['symptoms'],
+                        'treatment': pest_info['treatment']
+                    })
+        
+        # Check for diseases
+        for disease_category, diseases in self.disease_database.items():
+            for disease_name, disease_info in diseases.items():
+                if crop_lower in disease_info.get('affected_crops', []):
+                    conditions = disease_info['conditions']
+                    
+                    temp_ok = conditions['temp_range'][0] <= temp <= conditions['temp_range'][1]
+                    humidity_ok = conditions['humidity_range'][0] <= humidity <= conditions['humidity_range'][1]
+                    rainfall_ok = conditions['rainfall_range'][0] <= rainfall <= conditions['rainfall_range'][1]
+                    
+                    if temp_ok and humidity_ok and rainfall_ok:
+                        risks['diseases'].append({
+                            'name': disease_name,
+                            'category': disease_category,
+                            'risk_level': 'high',
+                            'symptoms': disease_info['symptoms'],
+                            'treatment': disease_info['treatment']
+                        })
+        
+        # Determine overall risk level
+        high_risks = len([p for p in risks['pests'] if p['risk_level'] == 'high']) + \
+                    len([d for d in risks['diseases'] if d['risk_level'] == 'high'])
+        
+        if high_risks > 0:
+            risks['overall_risk'] = 'high'
+        elif len(risks['pests']) + len(risks['diseases']) > 0:
+            risks['overall_risk'] = 'medium'
+        
+        # Generate recommendations
+        risks['recommendations'] = self._generate_recommendations(risks, crop_type)
+        
+        return risks
+    
+    def _generate_recommendations(self, risks: Dict, crop_type: str) -> List[str]:
+        """Generate specific recommendations based on risk assessment"""
+        recommendations = []
+        
+        if risks['overall_risk'] == 'high':
+            recommendations.append("🚨 HIGH RISK: Immediate action required. Monitor crops daily.")
+        elif risks['overall_risk'] == 'medium':
+            recommendations.append("⚠️ MEDIUM RISK: Increased monitoring recommended.")
+        else:
+            recommendations.append("✅ LOW RISK: Continue regular monitoring.")
+        
+        # Add specific recommendations for pests
+        for pest in risks['pests']:
+            if pest['risk_level'] == 'high':
+                recommendations.append(f"🐛 High risk of {pest['name']}: {pest['treatment']}")
+        
+        # Add specific recommendations for diseases
+        for disease in risks['diseases']:
+            if disease['risk_level'] == 'high':
+                recommendations.append(f"🦠 High risk of {disease['name']}: {disease['treatment']}")
+        
+        # General recommendations
+        recommendations.append("📅 Monitor crops every 2-3 days during high-risk periods.")
+        recommendations.append("🔍 Look for early symptoms and take preventive action.")
+        recommendations.append("🌱 Consider resistant varieties for future plantings.")
+        
+        return recommendations
+    
+    def _combine_predictions(self, llama_prediction: str, risk_assessment: Dict, crop_type: str) -> str:
+        """Combine Llama 2 prediction with rule-based assessment"""
+        combined = f"🤖 AI Analysis for {crop_type}:\n\n"
+        combined += llama_prediction + "\n\n"
+        
+        combined += "📊 Risk Assessment:\n"
+        combined += f"Overall Risk Level: {risk_assessment['overall_risk'].upper()}\n\n"
+        
+        if risk_assessment['pests']:
+            combined += "🐛 Pest Risks:\n"
+            for pest in risk_assessment['pests']:
+                combined += f"- {pest['name']} ({pest['risk_level']} risk)\n"
+            combined += "\n"
+        
+        if risk_assessment['diseases']:
+            combined += "🦠 Disease Risks:\n"
+            for disease in risk_assessment['diseases']:
+                combined += f"- {disease['name']} ({disease['risk_level']} risk)\n"
+            combined += "\n"
+        
+        combined += "💡 Recommendations:\n"
+        for rec in risk_assessment['recommendations']:
+            combined += f"- {rec}\n"
+        
+        return combined
+    
+    def _rule_based_prediction(self, crop_type: str, weather_data: Dict, soil_data: Dict) -> str:
+        """Fallback rule-based prediction when Llama 2 is not available"""
+        temp = weather_data.get('temperature', 25)
+        humidity = weather_data.get('humidity', 65)
+        rainfall = weather_data.get('rainfall', 50)
+        
+        prediction = f"Pest and Disease Risk Assessment for {crop_type}:\n\n"
+        
+        # Basic risk assessment
+        if temp > 30 and humidity > 80:
+            prediction += "⚠️ High risk of fungal diseases due to hot, humid conditions.\n"
+        elif temp < 15 and humidity > 85:
+            prediction += "⚠️ High risk of bacterial diseases due to cool, wet conditions.\n"
+        elif temp > 25 and humidity < 40:
+            prediction += "⚠️ High risk of pest infestation due to hot, dry conditions.\n"
+        else:
+            prediction += "✅ Conditions appear favorable with low disease risk.\n"
+        
+        # General recommendations
+        prediction += "\nGeneral Recommendations:\n"
+        prediction += "- Monitor crops regularly for early signs of problems\n"
+        prediction += "- Maintain proper spacing for air circulation\n"
+        prediction += "- Use disease-resistant varieties when possible\n"
+        prediction += "- Practice crop rotation to break pest cycles\n"
+        
+        return prediction

models/enhanced_weather_analyst.py

@@ -0,0 +1,363 @@
+import os
+import requests
+import json
+import logging
+from datetime import datetime, timedelta
+from typing import Dict, List, Optional
+import pandas as pd
+from dotenv import load_dotenv
+from transformers import AutoTokenizer, AutoModelForCausalLM
+import torch
+
+# Load environment variables
+load_dotenv()
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+class EnhancedWeatherAnalyst:
+    """
+    Enhanced weather analyst that uses real weather APIs and Llama 2 for intelligent forecasting
+    """
+    
+    def __init__(self, openweather_api_key: Optional[str] = None):
+        self.openweather_api_key = openweather_api_key or os.getenv('OPENWEATHER_API_KEY')
+        self.base_url = "https://api.openweathermap.org/data/2.5"
+        
+        # Initialize Llama 2 model for weather analysis
+        self.device = "cuda" if torch.cuda.is_available() else "cpu"
+        self.model_name = "meta-llama/Llama-2-7b-chat-hf"
+        
+        try:
+            self.tokenizer = AutoTokenizer.from_pretrained(self.model_name)
+            self.model = AutoModelForCausalLM.from_pretrained(
+                self.model_name,
+                torch_dtype=torch.float16 if self.device == "cuda" else torch.float32,
+                device_map="auto" if self.device == "cuda" else None
+            )
+            logger.info(f"Loaded Llama 2 model on {self.device}")
+        except Exception as e:
+            logger.warning(f"Could not load Llama 2 model: {e}. Using fallback analysis.")
+            self.model = None
+            self.tokenizer = None
+    
+    def get_current_weather(self, lat: float = 12.9716, lon: float = 77.5946) -> Dict:
+        """
+        Get current weather data from OpenWeatherMap API
+        Default coordinates are for Bangalore, India
+        """
+        if not self.openweather_api_key:
+            logger.warning("No OpenWeatherMap API key provided. Using simulated data.")
+            return self._get_simulated_weather()
+        
+        try:
+            url = f"{self.base_url}/weather"
+            params = {
+                'lat': lat,
+                'lon': lon,
+                'appid': self.openweather_api_key,
+                'units': 'metric'
+            }
+            
+            response = requests.get(url, params=params, timeout=10)
+            response.raise_for_status()
+            
+            data = response.json()
+            
+            return {
+                'temperature': data['main']['temp'],
+                'humidity': data['main']['humidity'],
+                'pressure': data['main']['pressure'],
+                'wind_speed': data['wind']['speed'],
+                'wind_direction': data['wind'].get('deg', 0),
+                'description': data['weather'][0]['description'],
+                'visibility': data.get('visibility', 10000) / 1000,  # Convert to km
+                'clouds': data['clouds']['all'],
+                'timestamp': datetime.now().isoformat()
+            }
+            
+        except Exception as e:
+            logger.error(f"Error fetching current weather: {e}")
+            return self._get_simulated_weather()
+    
+    def get_weather_forecast(self, lat: float = 12.9716, lon: float = 77.5946, days: int = 5) -> List[Dict]:
+        """
+        Get 5-day weather forecast from OpenWeatherMap API
+        """
+        if not self.openweather_api_key:
+            logger.warning("No OpenWeatherMap API key provided. Using simulated data.")
+            return self._get_simulated_forecast(days)
+        
+        try:
+            url = f"{self.base_url}/forecast"
+            params = {
+                'lat': lat,
+                'lon': lon,
+                'appid': self.openweather_api_key,
+                'units': 'metric'
+            }
+            
+            response = requests.get(url, params=params, timeout=10)
+            response.raise_for_status()
+            
+            data = response.json()
+            forecasts = []
+            
+            for item in data['list'][:days * 8]:  # 8 forecasts per day (3-hour intervals)
+                forecasts.append({
+                    'datetime': item['dt_txt'],
+                    'temperature': item['main']['temp'],
+                    'humidity': item['main']['humidity'],
+                    'pressure': item['main']['pressure'],
+                    'wind_speed': item['wind']['speed'],
+                    'wind_direction': item['wind'].get('deg', 0),
+                    'description': item['weather'][0]['description'],
+                    'rain_probability': item.get('pop', 0) * 100,  # Probability of precipitation
+                    'rain_volume': item.get('rain', {}).get('3h', 0),  # Rain volume for 3h
+                    'clouds': item['clouds']['all']
+                })
+            
+            return forecasts
+            
+        except Exception as e:
+            logger.error(f"Error fetching weather forecast: {e}")
+            return self._get_simulated_forecast(days)
+    
+    def analyze_weather_with_llama(self, weather_data: Dict, crop_type: str = "wheat") -> str:
+        """
+        Use Llama 2 to analyze weather data and provide agricultural insights
+        """
+        if not self.model or not self.tokenizer:
+            return self._get_fallback_analysis(weather_data, crop_type)
+        
+        try:
+            # Prepare context for Llama 2
+            context = f"""
+            As an agricultural weather expert, analyze the following weather data for {crop_type} farming:
+            
+            Current Weather:
+            - Temperature: {weather_data.get('temperature', 'N/A')}°C
+            - Humidity: {weather_data.get('humidity', 'N/A')}%
+            - Pressure: {weather_data.get('pressure', 'N/A')} hPa
+            - Wind Speed: {weather_data.get('wind_speed', 'N/A')} m/s
+            - Description: {weather_data.get('description', 'N/A')}
+            - Visibility: {weather_data.get('visibility', 'N/A')} km
+            - Cloud Cover: {weather_data.get('clouds', 'N/A')}%
+            
+            Provide specific agricultural recommendations for {crop_type} farming based on these conditions.
+            Focus on:
+            1. Crop growth implications
+            2. Irrigation needs
+            3. Pest and disease risks
+            4. Harvest timing considerations
+            5. Any weather warnings or alerts
+            
+            Keep the response concise and actionable for farmers.
+            """
+            
+            # Tokenize and generate response
+            inputs = self.tokenizer.encode(context, return_tensors="pt").to(self.device)
+            
+            with torch.no_grad():
+                outputs = self.model.generate(
+                    inputs,
+                    max_length=inputs.shape[1] + 200,
+                    num_return_sequences=1,
+                    temperature=0.7,
+                    do_sample=True,
+                    pad_token_id=self.tokenizer.eos_token_id
+                )
+            
+            response = self.tokenizer.decode(outputs[0], skip_special_tokens=True)
+            
+            # Extract the generated part (remove the input context)
+            generated_text = response[len(context):].strip()
+            
+            return generated_text if generated_text else self._get_fallback_analysis(weather_data, crop_type)
+            
+        except Exception as e:
+            logger.error(f"Error in Llama 2 analysis: {e}")
+            return self._get_fallback_analysis(weather_data, crop_type)
+    
+    def forecast_agricultural_conditions(self, lat: float = 12.9716, lon: float = 77.5946, 
+                                       crop_type: str = "wheat") -> Dict:
+        """
+        Main method to get comprehensive weather forecast with agricultural insights
+        """
+        try:
+            # Get current weather
+            current_weather = self.get_current_weather(lat, lon)
+            
+            # Get forecast
+            forecast_data = self.get_weather_forecast(lat, lon, 5)
+            
+            # Analyze with Llama 2
+            analysis = self.analyze_weather_with_llama(current_weather, crop_type)
+            
+            # Calculate agricultural metrics
+            avg_temp = sum([day['temperature'] for day in forecast_data[:8]]) / min(8, len(forecast_data))
+            total_rainfall = sum([day['rain_volume'] for day in forecast_data[:8]])
+            avg_humidity = sum([day['humidity'] for day in forecast_data[:8]]) / min(8, len(forecast_data))
+            
+            # Determine agricultural conditions
+            conditions = self._assess_agricultural_conditions(avg_temp, total_rainfall, avg_humidity, crop_type)
+            
+            return {
+                'current_weather': current_weather,
+                'forecast': forecast_data,
+                'analysis': analysis,
+                'agricultural_conditions': conditions,
+                'metrics': {
+                    'avg_temperature': round(avg_temp, 1),
+                    'total_rainfall': round(total_rainfall, 1),
+                    'avg_humidity': round(avg_humidity, 1)
+                },
+                'recommendations': self._generate_recommendations(conditions, crop_type)
+            }
+            
+        except Exception as e:
+            logger.error(f"Error in agricultural weather forecast: {e}")
+            return self._get_fallback_forecast(crop_type)
+    
+    def _assess_agricultural_conditions(self, temp: float, rainfall: float, humidity: float, crop_type: str) -> Dict:
+        """Assess agricultural conditions based on weather metrics"""
+        conditions = {
+            'temperature_status': 'optimal',
+            'rainfall_status': 'adequate',
+            'humidity_status': 'normal',
+            'overall_risk': 'low'
+        }
+        
+        # Temperature assessment
+        if temp < 10 or temp > 35:
+            conditions['temperature_status'] = 'extreme'
+            conditions['overall_risk'] = 'high'
+        elif temp < 15 or temp > 30:
+            conditions['temperature_status'] = 'suboptimal'
+            if conditions['overall_risk'] == 'low':
+                conditions['overall_risk'] = 'medium'
+        
+        # Rainfall assessment
+        if rainfall < 10:
+            conditions['rainfall_status'] = 'insufficient'
+            if conditions['overall_risk'] == 'low':
+                conditions['overall_risk'] = 'medium'
+        elif rainfall > 50:
+            conditions['rainfall_status'] = 'excessive'
+            if conditions['overall_risk'] == 'low':
+                conditions['overall_risk'] = 'medium'
+        
+        # Humidity assessment
+        if humidity < 30:
+            conditions['humidity_status'] = 'low'
+        elif humidity > 80:
+            conditions['humidity_status'] = 'high'
+            if conditions['overall_risk'] == 'low':
+                conditions['overall_risk'] = 'medium'
+        
+        return conditions
+    
+    def _generate_recommendations(self, conditions: Dict, crop_type: str) -> List[str]:
+        """Generate specific recommendations based on conditions"""
+        recommendations = []
+        
+        if conditions['temperature_status'] == 'extreme':
+            if conditions['temperature_status'] == 'extreme':
+                recommendations.append("⚠️ Extreme temperature detected. Consider protective measures like shade nets or heating systems.")
+        
+        if conditions['rainfall_status'] == 'insufficient':
+            recommendations.append("💧 Insufficient rainfall. Irrigation may be necessary.")
+        elif conditions['rainfall_status'] == 'excessive':
+            recommendations.append("🌧️ Excessive rainfall expected. Ensure proper drainage to prevent waterlogging.")
+        
+        if conditions['humidity_status'] == 'high':
+            recommendations.append("🌫️ High humidity conditions. Monitor for fungal diseases and ensure good air circulation.")
+        elif conditions['humidity_status'] == 'low':
+            recommendations.append("🏜️ Low humidity conditions. Consider misting or increased irrigation frequency.")
+        
+        if conditions['overall_risk'] == 'high':
+            recommendations.append("🚨 High risk conditions detected. Consult with agricultural experts before proceeding.")
+        
+        return recommendations
+    
+    def _get_simulated_weather(self) -> Dict:
+        """Fallback simulated weather data"""
+        return {
+            'temperature': 25.0,
+            'humidity': 65.0,
+            'pressure': 1013.25,
+            'wind_speed': 3.5,
+            'wind_direction': 180,
+            'description': 'partly cloudy',
+            'visibility': 10.0,
+            'clouds': 40,
+            'timestamp': datetime.now().isoformat()
+        }
+    
+    def _get_simulated_forecast(self, days: int) -> List[Dict]:
+        """Fallback simulated forecast data"""
+        forecasts = []
+        base_temp = 25.0
+        
+        for i in range(days * 8):
+            temp = base_temp + (i % 3 - 1) * 2  # Slight variation
+            forecasts.append({
+                'datetime': (datetime.now() + timedelta(hours=i*3)).strftime('%Y-%m-%d %H:%M:%S'),
+                'temperature': temp,
+                'humidity': 60 + (i % 5) * 2,
+                'pressure': 1013 + (i % 3 - 1) * 2,
+                'wind_speed': 2 + (i % 4),
+                'wind_direction': (i * 45) % 360,
+                'description': 'partly cloudy',
+                'rain_probability': 20 + (i % 3) * 10,
+                'rain_volume': (i % 7) * 0.5,
+                'clouds': 30 + (i % 4) * 10
+            })
+        
+        return forecasts
+    
+    def _get_fallback_analysis(self, weather_data: Dict, crop_type: str) -> str:
+        """Fallback analysis when Llama 2 is not available"""
+        temp = weather_data.get('temperature', 25)
+        humidity = weather_data.get('humidity', 65)
+        
+        analysis = f"Weather analysis for {crop_type} farming:\n"
+        analysis += f"Current temperature: {temp}°C - "
+        
+        if temp < 15:
+            analysis += "Cool conditions may slow growth.\n"
+        elif temp > 30:
+            analysis += "Hot conditions may stress plants.\n"
+        else:
+            analysis += "Optimal temperature range.\n"
+        
+        analysis += f"Humidity: {humidity}% - "
+        if humidity > 80:
+            analysis += "High humidity increases disease risk.\n"
+        elif humidity < 30:
+            analysis += "Low humidity may require more irrigation.\n"
+        else:
+            analysis += "Normal humidity levels.\n"
+        
+        return analysis
+    
+    def _get_fallback_forecast(self, crop_type: str) -> Dict:
+        """Fallback forecast when API fails"""
+        return {
+            'current_weather': self._get_simulated_weather(),
+            'forecast': self._get_simulated_forecast(5),
+            'analysis': self._get_fallback_analysis(self._get_simulated_weather(), crop_type),
+            'agricultural_conditions': {
+                'temperature_status': 'optimal',
+                'rainfall_status': 'adequate',
+                'humidity_status': 'normal',
+                'overall_risk': 'low'
+            },
+            'metrics': {
+                'avg_temperature': 25.0,
+                'total_rainfall': 15.0,
+                'avg_humidity': 65.0
+            },
+            'recommendations': ["Monitor weather conditions regularly."]
+        }

models/farmer_advisor.py

@@ -0,0 +1,100 @@
+import sqlite3
+import pandas as pd
+import joblib
+from sklearn.tree import DecisionTreeClassifier, export_text
+from sklearn.preprocessing import LabelEncoder
+from sklearn.model_selection import train_test_split
+from sklearn.metrics import accuracy_score
+import warnings
+import os
+
+class FarmerAdvisor:
+    def __init__(self, db_path='Models/database/sustainable_farming.db'):
+        self.db_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'database', 'sustainable_farming.db'))
+        self.model = None
+        self.encoders = {}
+        model_path = 'models/farmer_advisor_model.pkl'
+        encoder_path = 'models/farmer_encoders.pkl'
+        if os.path.exists(model_path) and os.path.exists(encoder_path):
+            self.model = joblib.load(model_path)
+            self.encoders = joblib.load(encoder_path)
+        else:
+            self._load_data()
+            self._preprocess()
+            self._train_model()
+
+    def _load_data(self):
+        with sqlite3.connect(self.db_path) as conn:
+            self.df = pd.read_sql("""
+                SELECT Soil_pH, Soil_Moisture, Temperature_C, Rainfall_mm,
+                       Fertilizer_Usage_kg, Pesticide_Usage_kg, Crop_Yield_ton,
+                       Crop_Type, Sustainability_Score
+                FROM farmer_advisor
+            """, conn)
+
+        # Calculate Carbon Footprint, Water, and Erosion Scores
+        self.df["Carbon_Footprint_Score"] = 100 - self.df["Fertilizer_Usage_kg"].fillna(0) * 0.6
+        self.df["Water_Score"] = 100 - self.df["Soil_Moisture"].fillna(0) * 0.7
+        self.df["Erosion_Score"] = 100 - self.df["Rainfall_mm"].fillna(0) * 0.5
+
+        # Clip the scores to be within 0 to 100
+        self.df["Carbon_Footprint_Score"] = self.df["Carbon_Footprint_Score"].clip(0, 100)
+        self.df["Water_Score"] = self.df["Water_Score"].clip(0, 100)
+        self.df["Erosion_Score"] = self.df["Erosion_Score"].clip(0, 100)
+
+    def _preprocess(self):
+        # Drop rows where Crop_Type is missing
+        self.df.dropna(subset=['Crop_Type'], inplace=True)
+        # Initialize and fit the label encoder
+        self.encoders['crop'] = LabelEncoder()
+        self.df['Crop_encoded'] = self.encoders['crop'].fit_transform(self.df['Crop_Type'].astype(str))
+
+    def _train_model(self):
+        # Define feature columns
+        feature_cols = [
+            'Soil_pH', 'Soil_Moisture', 'Temperature_C', 'Rainfall_mm',
+            'Fertilizer_Usage_kg', 'Pesticide_Usage_kg', 'Crop_Yield_ton'
+        ]
+        # Prepare features and target
+        X = self.df[feature_cols].fillna(0)
+        y = self.df['Crop_encoded']
+        X_train, X_test, y_train, y_test = train_test_split(
+            X, y, test_size=0.2, stratify=y, random_state=42
+        )
+        self.model = DecisionTreeClassifier(
+            max_depth=8,
+            min_samples_split=6,
+            random_state=42
+        )
+        self.model.fit(X_train, y_train)
+        os.makedirs('models', exist_ok=True)
+        joblib.dump(self.model, 'models/farmer_advisor_model.pkl')
+        joblib.dump(self.encoders, 'models/farmer_encoders.pkl')
+        # Only print accuracy and rules if running as a script (not imported)
+        if __name__ == "__main__":
+            y_pred = self.model.predict(X_test)
+            acc = accuracy_score(y_test, y_pred)
+            print(f"\nFarmerAdvisor Model Accuracy: {acc:.2f}")
+            with warnings.catch_warnings():
+                warnings.simplefilter("ignore")
+                rules = export_text(self.model, feature_names=feature_cols)
+                print("\nDecision Tree Rules for Crop Recommendation:\n")
+                print(rules)
+
+    def recommend(self, soil_ph, soil_moisture, temp, rainfall, fertilizer, pesticide, crop_yield,
+                  carbon_score=None, water_score=None, erosion_score=None):
+        if self.model is None:
+            self.model = joblib.load('models/farmer_advisor_model.pkl')
+        if not self.encoders:
+            self.encoders = joblib.load('models/farmer_encoders.pkl')
+
+        input_df = pd.DataFrame([[
+            soil_ph, soil_moisture, temp, rainfall,
+            fertilizer, pesticide, crop_yield
+        ]], columns=[
+            'Soil_pH', 'Soil_Moisture', 'Temperature_C', 'Rainfall_mm',
+            'Fertilizer_Usage_kg', 'Pesticide_Usage_kg', 'Crop_Yield_ton'
+        ])
+
+        crop_code = self.model.predict(input_df)[0]
+        return self.encoders['crop'].inverse_transform([crop_code])[0]

models/market_Researcher.py

@@ -0,0 +1,114 @@
+import sqlite3
+import pandas as pd
+import joblib
+import os
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.model_selection import train_test_split
+from sklearn.preprocessing import LabelEncoder, StandardScaler
+
+class MarketResearcher:
+    def __init__(self, db_path="Models/database/sustainable_farming.db"):
+        # Prefer explicitly provided db_path if it exists; else fall back to project default
+        provided_path = db_path if db_path else ""
+        default_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'database', 'sustainable_farming.db'))
+        resolved_path = os.path.abspath(provided_path)
+        self.db_path = resolved_path if os.path.exists(resolved_path) else default_path
+        self.models = {}
+        self.encoders = {}
+        self.scalers = {}
+        # Only train if any model/encoder/scaler file is missing for any product
+        base_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'models'))
+        with sqlite3.connect(self.db_path) as conn:
+            products = pd.read_sql(
+                "SELECT DISTINCT Product FROM market_researcher", conn
+            )['Product'].dropna().unique().tolist()
+        missing = False
+        for product in products:
+            model_name = product.strip().lower().replace(" ", "_")
+            if not (os.path.exists(os.path.join(base_dir, f"market_model_{model_name}.pkl")) and \
+                    os.path.exists(os.path.join(base_dir, f"market_encoder_{model_name}.pkl")) and \
+                    os.path.exists(os.path.join(base_dir, f"market_scaler_{model_name}.pkl"))):
+                missing = True
+                break
+        if missing:
+            self._train_all_models()
+
+    def _train_all_models(self):
+        with sqlite3.connect(self.db_path) as conn:
+            products = pd.read_sql(
+                "SELECT DISTINCT Product FROM market_researcher", conn
+            )['Product'].dropna().unique().tolist()
+
+            for product in products:
+                model_name = product.strip().lower().replace(" ", "_")
+                base_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'models'))
+                model_path = os.path.join(base_dir, f"market_model_{model_name}.pkl")
+                encoder_path = os.path.join(base_dir, f"market_encoder_{model_name}.pkl")
+                scaler_path = os.path.join(base_dir, f"market_scaler_{model_name}.pkl")
+                if os.path.exists(model_path) and os.path.exists(encoder_path) and os.path.exists(scaler_path):
+                    continue
+                df = pd.read_sql("""
+                    SELECT Product, Market_Price_per_ton, Demand_Index, Supply_Index,
+                           Competitor_Price_per_ton, Economic_Indicator,
+                           Weather_Impact_Score, Seasonal_Factor, Consumer_Trend_Index
+                    FROM market_researcher
+                    WHERE Product = ?
+                """, conn, params=(product,))
+                if len(df) < 10:
+                    continue
+                df['Seasonal_Factor'] = df['Seasonal_Factor'].fillna('None')
+                le = LabelEncoder()
+                df['Seasonal_Factor_Encoded'] = le.fit_transform(df['Seasonal_Factor'])
+                self.encoders[product] = le
+                features = ['Demand_Index', 'Supply_Index', 'Competitor_Price_per_ton',
+                            'Economic_Indicator', 'Weather_Impact_Score',
+                            'Seasonal_Factor_Encoded', 'Consumer_Trend_Index']
+                X = df[features]
+                y = df['Market_Price_per_ton']
+                scaler = StandardScaler()
+                X_scaled = scaler.fit_transform(X)
+                self.scalers[product] = scaler
+                X_train, _, y_train, _ = train_test_split(X_scaled, y, test_size=0.2, random_state=42)
+                model = RandomForestRegressor(n_estimators=100, random_state=42)
+                model.fit(X_train, y_train)
+                os.makedirs(base_dir, exist_ok=True)
+                joblib.dump(model, model_path)
+                joblib.dump(le, encoder_path)
+                joblib.dump(scaler, scaler_path)
+
+    def forecast(self, product, input_features):
+        model_name = product.strip().lower().replace(" ", "_")
+        model_path = f"models/market_model_{model_name}.pkl"
+        encoder_path = f"models/market_encoder_{model_name}.pkl"
+        scaler_path = f"models/market_scaler_{model_name}.pkl"
+
+        if not os.path.exists(model_path) or not os.path.exists(encoder_path) or not os.path.exists(scaler_path):
+            raise ValueError(f"No trained model found for product: {product}")
+
+        model = joblib.load(model_path)
+        le = joblib.load(encoder_path)
+        scaler = joblib.load(scaler_path)
+
+        sf = input_features.get('Seasonal_Factor', 'None')
+        if sf not in le.classes_:
+            sf = le.classes_[0]
+
+        sf_encoded = le.transform([sf])[0]
+
+        input_df = pd.DataFrame([[
+            input_features.get('Demand_Index', 0),
+            input_features.get('Supply_Index', 0),
+            input_features.get('Competitor_Price_per_ton', 0),
+            input_features.get('Economic_Indicator', 0),
+            input_features.get('Weather_Impact_Score', 0),
+            sf_encoded,
+            input_features.get('Consumer_Trend_Index', 0)
+        ]], columns=[
+            'Demand_Index', 'Supply_Index', 'Competitor_Price_per_ton',
+            'Economic_Indicator', 'Weather_Impact_Score',
+            'Seasonal_Factor_Encoded', 'Consumer_Trend_Index'
+        ])
+
+        input_scaled = scaler.transform(input_df)
+        prediction = model.predict(input_scaled)
+        return prediction.tolist()

models/market_model_corn.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b70f05f98895fe52e199e193be035af378cd2889d79879257ce0f9b22617db69
+size 17862433

models/market_model_rice.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:d6c5c89d70d15b43c43298a2f7c7b455c07c9b8fdb4ba7cd8a0e0f174e82192c
+size 18663073

models/market_model_soybean.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:381882ee9739adaf56c99433be9cb22ea5218e204482253bcf8970ba52bde543
+size 18323953

models/market_model_wheat.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b948159a30a1767989ca39f95d29cd555c504efb882e6560c015c499f030bb9f
+size 18040417

models/pest_disease_predictor.py

@@ -0,0 +1,46 @@
+class PestDiseasePredictor:
+    def predict(self, crop_type, soil_ph, soil_moisture, temperature, rainfall):
+        # Example rules (customize as needed)
+        crop = crop_type.lower()
+        if crop == "tomato":
+            if temperature > 28 and rainfall > 60:
+                return "High risk of aphids in tomatoes; consider neem oil treatment."
+            elif temperature < 15:
+                return "Risk of late blight in tomatoes; monitor for leaf spots."
+        elif crop == "wheat":
+            if rainfall > 80:
+                return "High risk of rust disease in wheat; consider fungicide spray."
+        elif crop == "rice":
+            if temperature > 30 and rainfall > 100:
+                return "High risk of bacterial leaf blight in rice; ensure proper drainage."
+        elif crop == "corn":
+            if temperature > 32 and rainfall < 40:
+                return "Risk of corn borer infestation; monitor for larvae."
+        elif crop == "soybeans":
+            if soil_moisture > 35:
+                return "Risk of root rot in soybeans; avoid over-irrigation."
+        # Add more rules for other crops as needed
+        return "No significant pest or disease risk detected." 
+class PestDiseasePredictor:
+    def predict(self, crop_type, soil_ph, soil_moisture, temperature, rainfall):
+        # Example rules (customize as needed)
+        crop = crop_type.lower()
+        if crop == "tomato":
+            if temperature > 28 and rainfall > 60:
+                return "High risk of aphids in tomatoes; consider neem oil treatment."
+            elif temperature < 15:
+                return "Risk of late blight in tomatoes; monitor for leaf spots."
+        elif crop == "wheat":
+            if rainfall > 80:
+                return "High risk of rust disease in wheat; consider fungicide spray."
+        elif crop == "rice":
+            if temperature > 30 and rainfall > 100:
+                return "High risk of bacterial leaf blight in rice; ensure proper drainage."
+        elif crop == "corn":
+            if temperature > 32 and rainfall < 40:
+                return "Risk of corn borer infestation; monitor for larvae."
+        elif crop == "soybeans":
+            if soil_moisture > 35:
+                return "Risk of root rot in soybeans; avoid over-irrigation."
+        # Add more rules for other crops as needed
+        return "No significant pest or disease risk detected." 

models/rain_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5f442fe0bc96a49622c85a4bcf216b4b56ecc62c081a805d9973b6dd8d44db34
+size 91073185

models/speech_interface.py

@@ -0,0 +1,487 @@
+import streamlit as st
+import speech_recognition as sr
+import pyttsx3
+from gtts import gTTS
+import io
+import tempfile
+import os
+import threading
+import time
+from typing import Optional, Dict, List
+import logging
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+class SpeechInterface:
+    """
+    Comprehensive speech interface supporting multiple languages for farmers
+    """
+    
+    def __init__(self):
+        self.recognizer = sr.Recognizer()
+        self.microphone = None
+        self.pyaudio_available = False
+        
+        # Try to initialize microphone with error handling
+        try:
+            self.microphone = sr.Microphone()
+            self.pyaudio_available = True
+            logger.info("PyAudio and microphone initialized successfully")
+        except AttributeError as e:
+            if "PyAudio" in str(e):
+                logger.warning("PyAudio not available. Voice input will be disabled.")
+                self.pyaudio_available = False
+            else:
+                logger.error(f"Microphone initialization error: {e}")
+                self.pyaudio_available = False
+        except Exception as e:
+            logger.error(f"Unexpected error initializing microphone: {e}")
+            self.pyaudio_available = False
+        
+        # Language mapping for speech recognition and synthesis
+        self.language_codes = {
+            'English': 'en',
+            'Hindi': 'hi',
+            'Telugu': 'te',
+            'Kannada': 'kn',
+            'Tamil': 'ta',
+            'Malayalam': 'ml',
+            'Marathi': 'mr',
+            'Bengali': 'bn',
+            'Gujarati': 'gu',
+            'Punjabi': 'pa',
+            'Urdu': 'ur',
+            'French': 'fr',
+            'Spanish': 'es'
+        }
+        
+        # Initialize text-to-speech engine
+        try:
+            self.tts_engine = pyttsx3.init()
+            self.tts_engine.setProperty('rate', 150)  # Speed of speech
+            self.tts_engine.setProperty('volume', 0.9)  # Volume level
+        except Exception as e:
+            logger.warning(f"Could not initialize TTS engine: {e}")
+            self.tts_engine = None
+    
+    def speech_to_text(self, language: str = 'English', timeout: int = 5) -> Optional[str]:
+        """
+        Convert speech to text using microphone input
+        """
+        if not self.pyaudio_available or self.microphone is None:
+            st.error("❌ Microphone not available. PyAudio is not installed or not working properly.")
+            st.info("💡 **To fix this:**\n"
+                   "1. Install PyAudio: `pip install pyaudio`\n"
+                   "2. On Windows, you might need: `pip install pipwin` then `pipwin install pyaudio`\n"
+                   "3. Or use conda: `conda install pyaudio`")
+            return None
+        
+        try:
+            with self.microphone as source:
+                # Adjust for ambient noise
+                self.recognizer.adjust_for_ambient_noise(source, duration=0.5)
+                
+                # Show listening indicator
+                st.info("🎤 Listening... Speak now!")
+                
+                # Listen for audio
+                audio = self.recognizer.listen(source, timeout=timeout, phrase_time_limit=10)
+                
+                # Show processing indicator
+                st.info("🔄 Processing your speech...")
+                
+                # Convert speech to text
+                language_code = self.language_codes.get(language, 'en')
+                text = self.recognizer.recognize_google(audio, language=language_code)
+                
+                st.success(f"✅ Heard: {text}")
+                return text
+                
+        except sr.WaitTimeoutError:
+            st.warning("⏰ No speech detected. Please try again.")
+            return None
+        except sr.UnknownValueError:
+            st.error("❌ Could not understand the speech. Please speak clearly.")
+            return None
+        except sr.RequestError as e:
+            st.error(f"❌ Speech recognition service error: {e}")
+            return None
+        except Exception as e:
+            st.error(f"❌ Unexpected error: {e}")
+            return None
+    
+    def text_to_speech(self, text: str, language: str = 'English', use_gtts: bool = True) -> bool:
+        """
+        Convert text to speech using either gTTS (online) or pyttsx3 (offline)
+        """
+        try:
+            if use_gtts and text.strip():
+                # Use Google Text-to-Speech (online, better quality, supports more languages)
+                language_code = self.language_codes.get(language, 'en')
+                tts = gTTS(text=text, lang=language_code, slow=False)
+                
+                # Create temporary file with better handling
+                import uuid
+                temp_filename = f"tts_{uuid.uuid4().hex}.mp3"
+                temp_path = os.path.join(tempfile.gettempdir(), temp_filename)
+                
+                try:
+                    tts.save(temp_path)
+                    
+                    # Play audio in Streamlit
+                    with open(temp_path, 'rb') as audio_file:
+                        audio_bytes = audio_file.read()
+                        st.audio(audio_bytes, format='audio/mp3')
+                        st.info(f"🔊 Audio generated! If you don't hear anything, check your speakers/headphones and browser audio settings.")
+                        
+                        # Provide download option as fallback
+                        st.download_button(
+                            label="⬇️ Download Audio File",
+                            data=audio_bytes,
+                            file_name=f"recommendation_audio_{uuid.uuid4().hex[:8]}.mp3",
+                            mime="audio/mp3",
+                            help="Download the audio file to play it in your preferred audio player"
+                        )
+                    
+                    # Clean up with retry mechanism
+                    try:
+                        os.unlink(temp_path)
+                    except PermissionError:
+                        # File might still be in use, try again after a short delay
+                        import time
+                        time.sleep(0.5)
+                        try:
+                            os.unlink(temp_path)
+                        except:
+                            # If still can't delete, just leave it - temp files are cleaned up by system
+                            pass
+                    
+                    return True
+                    
+                except Exception as e:
+                    logger.error(f"Error with gTTS file handling: {e}")
+                    # Fallback to pyttsx3
+                    if self.tts_engine:
+                        self.tts_engine.say(text)
+                        self.tts_engine.runAndWait()
+                        return True
+                    return False
+                
+            elif self.tts_engine and text.strip():
+                # Use pyttsx3 (offline, limited language support)
+                try:
+                    self.tts_engine.say(text)
+                    self.tts_engine.runAndWait()
+                    st.info("🔊 Playing audio using offline TTS engine...")
+                    return True
+                except Exception as e:
+                    logger.error(f"Error with pyttsx3: {e}")
+                    st.error(f"❌ Offline TTS error: {e}")
+                    return False
+                
+            else:
+                if not text.strip():
+                    st.warning("⚠️ No text provided to speak")
+                else:
+                    st.warning("⚠️ No TTS engine available. Please check your internet connection for online TTS or install offline TTS dependencies.")
+                return False
+                
+        except Exception as e:
+            logger.error(f"Error in text-to-speech: {e}")
+            st.error(f"❌ Text-to-speech error: {e}")
+            return False
+    
+    def create_voice_input_widget(self, label: str, language: str = 'English', 
+                                key: str = None, help_text: str = None) -> Optional[str]:
+        """
+        Create a voice input widget for Streamlit
+        """
+        col1, col2 = st.columns([3, 1])
+        
+        # Get the current value from session state
+        text_key = f"{key}_text" if key else "text_input"
+        voice_result_key = f"{key}_voice_result" if key else "voice_result"
+        
+        # Initialize session state for voice result
+        if voice_result_key not in st.session_state:
+            st.session_state[voice_result_key] = ""
+        
+        with col1:
+            text_input = st.text_input(
+                label, 
+                key=text_key,
+                help=help_text
+            )
+        
+        with col2:
+            if st.button("🎤 Voice", key=f"{key}_voice_btn" if key else None, help="Click to speak"):
+                if not self.pyaudio_available:
+                    st.error("❌ Microphone not available")
+                    return text_input
+                
+                with st.spinner("Preparing microphone..."):
+                    time.sleep(1)  # Give time for microphone to initialize
+                
+                try:
+                    voice_text = self.speech_to_text(language)
+                    if voice_text:
+                        # Store voice input in session state
+                        st.session_state[voice_result_key] = voice_text
+                        st.success(f"✅ Voice input: {voice_text}")
+                        # Show the voice input in a separate display
+                        st.info(f"🎤 Voice input captured: **{voice_text}**")
+                        st.info("💡 Copy this text and paste it into the input field above")
+                        # Force a rerun to update the text input
+                        st.rerun()
+                    else:
+                        st.warning("⚠️ No voice input detected")
+                except Exception as e:
+                    st.error(f"❌ Voice input error: {e}")
+                    logger.error(f"Voice input error: {e}")
+        
+        # Show voice result if available
+        if st.session_state.get(voice_result_key):
+            st.info(f"🎤 Last voice input: **{st.session_state[voice_result_key]}**")
+        
+        return text_input
+    
+    def create_voice_output_button(self, text: str, language: str = 'English', 
+                                 button_text: str = "🔊 Listen", key: str = None):
+        """
+        Create a voice output button for Streamlit
+        """
+        if st.button(button_text, key=f"{key}_speak" if key else None, help="Click to hear the text"):
+            if not text or not text.strip():
+                st.warning("⚠️ No text to speak")
+                return
+            
+            with st.spinner("Generating speech..."):
+                success = self.text_to_speech(text, language)
+                if success:
+                    st.success("✅ Audio generated successfully!")
+                else:
+                    st.error("❌ Failed to generate audio. Please try again.")
+    
+    def create_voice_interface_for_sustainability(self, language: str = 'English') -> Dict:
+        """
+        Create voice interface specifically for sustainability tracker
+        """
+        st.markdown("### 🎤 Voice Input for Sustainability Data")
+        
+        # Voice input for water usage
+        water_usage_text = self.create_voice_input_widget(
+            "💧 Water Usage (ML/ha) - Voice Input",
+            language=language,
+            key="water_voice",
+            help_text="Speak the water usage amount"
+        )
+        
+        # Voice input for fertilizer usage
+        fertilizer_usage_text = self.create_voice_input_widget(
+            "🧪 Fertilizer Usage (tons/ha) - Voice Input", 
+            language=language,
+            key="fertilizer_voice",
+            help_text="Speak the fertilizer usage amount"
+        )
+        
+        # Voice input for crop rotation
+        rotation_text = self.create_voice_input_widget(
+            "🔄 Crop Rotation (Yes/No) - Voice Input",
+            language=language, 
+            key="rotation_voice",
+            help_text="Say 'Yes' or 'No' for crop rotation"
+        )
+        
+        # Get voice results from session state
+        water_voice = st.session_state.get("water_voice_voice_result", "")
+        fertilizer_voice = st.session_state.get("fertilizer_voice_voice_result", "")
+        rotation_voice = st.session_state.get("rotation_voice_voice_result", "")
+        
+        # Use voice input if available, otherwise use text input
+        water_usage_text = water_voice if water_voice else water_usage_text
+        fertilizer_usage_text = fertilizer_voice if fertilizer_voice else fertilizer_usage_text
+        rotation_text = rotation_voice if rotation_voice else rotation_text
+        
+        # Process voice inputs
+        data = {}
+        
+        if water_usage_text:
+            try:
+                # Extract numbers from voice input
+                import re
+                numbers = re.findall(r'\d+\.?\d*', water_usage_text)
+                if numbers:
+                    data['water_score'] = float(numbers[0])
+            except:
+                st.warning("Could not parse water usage from voice input")
+        
+        if fertilizer_usage_text:
+            try:
+                import re
+                numbers = re.findall(r'\d+\.?\d*', fertilizer_usage_text)
+                if numbers:
+                    data['fertilizer_use'] = float(numbers[0])
+            except:
+                st.warning("Could not parse fertilizer usage from voice input")
+        
+        if rotation_text:
+            rotation_lower = rotation_text.lower()
+            if any(word in rotation_lower for word in ['yes', 'haan', 'ಹೌದು', 'అవును', 'ஆம்', 'അതെ', 'हाँ', 'oui', 'sí']):
+                data['rotation'] = True
+            elif any(word in rotation_lower for word in ['no', 'nahi', 'ಇಲ್ಲ', 'లేదు', 'இல்லை', 'ഇല്ല', 'नहीं', 'non', 'no']):
+                data['rotation'] = False
+        
+        return data
+    
+    def create_voice_interface_for_farm_details(self, language: str = 'English') -> Dict:
+        """
+        Create voice interface for farm details input
+        """
+        st.markdown("### 🎤 Voice Input for Farm Details")
+        
+        # Voice input for farm size
+        farm_size_text = self.create_voice_input_widget(
+            "🌾 Farm Size (hectares) - Voice Input",
+            language=language,
+            key="farm_size_voice",
+            help_text="Speak the farm size in hectares"
+        )
+        
+        # Voice input for crop preference
+        crop_preference_text = self.create_voice_input_widget(
+            "🌱 Crop Preference - Voice Input",
+            language=language,
+            key="crop_preference_voice", 
+            help_text="Speak your crop preference (Grains, Vegetables, Fruits)"
+        )
+        
+        # Voice input for soil type
+        soil_type_text = self.create_voice_input_widget(
+            "🗺️ Soil Type - Voice Input",
+            language=language,
+            key="soil_type_voice",
+            help_text="Speak the soil type (Loamy, Sandy, Clay)"
+        )
+        
+        # Get voice results from session state
+        farm_size_voice = st.session_state.get("farm_size_voice_voice_result", "")
+        crop_preference_voice = st.session_state.get("crop_preference_voice_voice_result", "")
+        soil_type_voice = st.session_state.get("soil_type_voice_voice_result", "")
+        
+        # Use voice input if available, otherwise use text input
+        farm_size_text = farm_size_voice if farm_size_voice else farm_size_text
+        crop_preference_text = crop_preference_voice if crop_preference_voice else crop_preference_text
+        soil_type_text = soil_type_voice if soil_type_voice else soil_type_text
+        
+        # Process voice inputs
+        data = {}
+        
+        # Debug: Show what was captured
+        if farm_size_text or crop_preference_text or soil_type_text:
+            st.info(f"🎤 Voice inputs captured: Farm Size='{farm_size_text}', Crop='{crop_preference_text}', Soil='{soil_type_text}'")
+        
+        if farm_size_text:
+            try:
+                import re
+                numbers = re.findall(r'\d+', farm_size_text)
+                if numbers:
+                    data['land_size'] = int(numbers[0])
+                    st.success(f"✅ Parsed land size: {data['land_size']} hectares")
+                else:
+                    st.warning("Could not find numbers in farm size voice input")
+            except Exception as e:
+                st.warning(f"Could not parse farm size from voice input: {e}")
+        
+        if crop_preference_text:
+            crop_lower = crop_preference_text.lower()
+            if any(word in crop_lower for word in ['grain', 'grains', 'अनाज', 'ಧಾನ್ಯ', 'ధాన్యం', 'தானியம்', 'ധാന്യം']):
+                data['crop_preference'] = 'Grains'
+                st.success(f"✅ Parsed crop preference: {data['crop_preference']}")
+            elif any(word in crop_lower for word in ['vegetable', 'vegetables', 'सब्जी', 'ತರಕಾರಿ', 'కూరగాయలు', 'காய்கறி', 'പച്ചക്കറി']):
+                data['crop_preference'] = 'Vegetables'
+                st.success(f"✅ Parsed crop preference: {data['crop_preference']}")
+            elif any(word in crop_lower for word in ['fruit', 'fruits', 'फल', 'ಹಣ್ಣು', 'పండు', 'பழம்', 'പഴം']):
+                data['crop_preference'] = 'Fruits'
+                st.success(f"✅ Parsed crop preference: {data['crop_preference']}")
+            else:
+                st.warning(f"Could not recognize crop preference from: '{crop_preference_text}'")
+        
+        if soil_type_text:
+            soil_lower = soil_type_text.lower()
+            if any(word in soil_lower for word in ['loamy', 'loam', 'दोमट', 'ಲೋಮಿ', 'లోమి', 'லோமி', 'ലോമി']):
+                data['soil_type'] = 'Loamy'
+                st.success(f"✅ Parsed soil type: {data['soil_type']}")
+            elif any(word in soil_lower for word in ['sandy', 'sand', 'बालू', 'ಮರಳು', 'ఇసుక', 'மணல்', 'മണൽ']):
+                data['soil_type'] = 'Sandy'
+                st.success(f"✅ Parsed soil type: {data['soil_type']}")
+            elif any(word in soil_lower for word in ['clay', 'चिकनी', 'ಕ್ಲೇ', 'క్లే', 'களிமண்', 'കളിമണ്ണ്']):
+                data['soil_type'] = 'Clay'
+                st.success(f"✅ Parsed soil type: {data['soil_type']}")
+            else:
+                st.warning(f"Could not recognize soil type from: '{soil_type_text}'")
+        
+        return data
+    
+    def create_voice_help_system(self, language: str = 'English'):
+        """
+        Create a voice help system for farmers
+        """
+        st.markdown("### 🎤 Voice Help System")
+        
+        help_texts = {
+            'English': {
+                'welcome': "Welcome to the Sustainable Farming AI Platform. You can use voice commands to interact with the system.",
+                'farm_details': "To enter farm details, speak your farm size, crop preference, and soil type.",
+                'sustainability': "To log sustainability data, speak your water usage, fertilizer usage, and whether you practice crop rotation.",
+                'recommendations': "Click the generate recommendation button to get AI-powered farming advice based on your inputs."
+            },
+            'Hindi': {
+                'welcome': "सस्टेनेबल फार्मिंग AI प्लेटफॉर्म में आपका स्वागत है। आप सिस्टम के साथ बातचीत करने के लिए आवाज कमांड का उपयोग कर सकते हैं।",
+                'farm_details': "फार्म विवरण दर्ज करने के लिए, अपने फार्म का आकार, फसल पसंद और मिट्टी का प्रकार बोलें।",
+                'sustainability': "सस्टेनेबलिटी डेटा लॉग करने के लिए, अपने पानी के उपयोग, उर्वरक के उपयोग और क्या आप फसल चक्रण का अभ्यास करते हैं, बोलें।",
+                'recommendations': "अपने इनपुट के आधार पर AI-संचालित खेती सलाह प्राप्त करने के लिए सिफारिश बटन पर क्लिक करें।"
+            },
+            'Telugu': {
+                'welcome': "సస్టైనబుల్ ఫార్మింగ్ AI ప్లాట్‌ఫారమ్‌కు స్వాగతం. మీరు సిస్టమ్‌తో ఇంటరాక్ట్ చేయడానికి వాయిస్ కమాండ్‌లను ఉపయోగించవచ్చు.",
+                'farm_details': "ఫార్మ్ వివరాలను నమోదు చేయడానికి, మీ ఫార్మ్ పరిమాణం, పంట ప్రాధాన్యత మరియు నేల రకాన్ని మాట్లాడండి.",
+                'sustainability': "సస్టైనబిలిటీ డేటాను లాగ్ చేయడానికి, మీ నీటి వినియోగం, ఎరువు వినియోగం మరియు మీరు పంట మార్పిడిని అభ్యసిస్తున్నారా అని మాట్లాడండి.",
+                'recommendations': "మీ ఇన్‌పుట్‌ల ఆధారంగా AI-ఆధారిత వ్యవసాయ సలహా పొందడానికి సిఫారసు బటన్‌పై క్లిక్ చేయండి."
+            }
+        }
+        
+        help_data = help_texts.get(language, help_texts['English'])
+        
+        col1, col2 = st.columns(2)
+        
+        with col1:
+            if st.button("🔊 Listen to Welcome", key="help_welcome"):
+                self.text_to_speech(help_data['welcome'], language)
+        
+        with col2:
+            if st.button("🔊 Listen to Farm Details Help", key="help_farm"):
+                self.text_to_speech(help_data['farm_details'], language)
+        
+        col3, col4 = st.columns(2)
+        
+        with col3:
+            if st.button("🔊 Listen to Sustainability Help", key="help_sustainability"):
+                self.text_to_speech(help_data['sustainability'], language)
+        
+        with col4:
+            if st.button("🔊 Listen to Recommendations Help", key="help_recommendations"):
+                self.text_to_speech(help_data['recommendations'], language)
+    
+    def get_supported_languages(self) -> List[str]:
+        """
+        Get list of supported languages
+        """
+        return list(self.language_codes.keys())
+    
+    def is_voice_available(self) -> bool:
+        """
+        Check if voice functionality is available
+        """
+        return self.pyaudio_available and self.microphone is not None
+

models/sustainability_Expert.py

@@ -0,0 +1,74 @@
+import sqlite3
+import pandas as pd
+import numpy as np
+import os
+
+class SustainabilityExpert:
+    def __init__(self, db_path="Models/database/sustainable_farming.db"):
+        self.db_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'database', 'sustainable_farming.db'))
+        self.sustainability_db = self._load_sustainability_data()
+
+    def _load_sustainability_data(self):
+        with sqlite3.connect(self.db_path) as conn:
+            df = pd.read_sql("""
+                SELECT Crop_Type, 
+                       AVG(Sustainability_Score) AS avg_score,
+                       AVG(Fertilizer_Usage_kg) AS avg_fertilizer,
+                       AVG(Soil_Moisture) AS avg_moisture,
+                       AVG(Pesticide_Usage_kg) AS avg_pesticide,
+                       AVG(Crop_Yield_ton) AS avg_yield
+                FROM farmer_advisor
+                GROUP BY Crop_Type
+            """, conn)
+            return df.set_index('Crop_Type').to_dict('index')
+
+    def calculate_carbon_score(self, fertilizer, pesticide, crop_yield):
+        # Carbon footprint score based on fertilizer and pesticide usage
+        # Lower usage and higher yield means better score
+        fertilizer_impact = 1 - (fertilizer / 100)  # Normalize to 0-1
+        pesticide_impact = 1 - (pesticide / 20)    # Normalize to 0-1
+        yield_impact = min(crop_yield / 5, 1)      # Normalize to 0-1
+        
+        return (0.4 * fertilizer_impact + 0.3 * pesticide_impact + 0.3 * yield_impact)
+
+    def calculate_water_score(self, soil_moisture, rainfall):
+        # Water score based on soil moisture and rainfall
+        # Optimal moisture is between 30-40%
+        moisture_score = 1 - abs(soil_moisture - 35) / 35
+        rainfall_score = min(rainfall / 100, 1)
+        
+        return (0.6 * moisture_score + 0.4 * rainfall_score)
+
+    def calculate_erosion_score(self, soil_ph, soil_moisture):
+        # Erosion score based on soil pH and moisture
+        # Optimal pH is between 6-7
+        ph_score = 1 - abs(soil_ph - 6.5) / 3.5
+        moisture_score = 1 - abs(soil_moisture - 35) / 35
+        
+        return (0.5 * ph_score + 0.5 * moisture_score)
+
+    def evaluate(self, crops, soil_ph, soil_moisture, rainfall, fertilizer, pesticide, crop_yield):
+        """Evaluate sustainability of crops based on environmental factors"""
+        results = {}
+        for crop in crops:
+            # Calculate individual scores
+            carbon_score = self.calculate_carbon_score(fertilizer, pesticide, crop_yield)
+            water_score = self.calculate_water_score(soil_moisture, rainfall)
+            erosion_score = self.calculate_erosion_score(soil_ph, soil_moisture)
+            
+            # Calculate overall sustainability score
+            sustainability_score = (
+                0.4 * carbon_score +
+                0.3 * water_score +
+                0.3 * erosion_score
+            )
+            
+            results[crop] = {
+                'sustainability': sustainability_score,
+                'carbon': carbon_score,
+                'water': water_score,
+                'erosion': erosion_score
+            }
+        
+        # Return the first crop's results since we're only evaluating one crop at a time
+        return crops[0], results[crops[0]]

models/sustainable_farming.db

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:808edbd5def2a5dc97c70c955c1a96666afd71aa0ce844b93d032714189ae4c8
+size 3477504

models/temp_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:5373e356705070954f5db3543e1d00088ecc78cd6afe57ee81a49daf4ae7e513
+size 91073329

models/test_recommendation.py

@@ -0,0 +1,29 @@
+from Models.central_coordinator import CentralCoordinator
+
+# Initialize the CentralCoordinator
+coordinator = CentralCoordinator()
+
+# Generate recommendation with sample input values and real-time weather for a city
+result = coordinator.generate_recommendation(
+    soil_ph=4.0,
+    soil_moisture=10,
+    temperature=32,
+    rainfall=35,
+    fertilizer=0.5,
+    pesticide=0.3,
+    crop_yield=15,
+    city_name="bangalore"  # Use real-time weather for Delhi
+)
+
+# Print recommendation results
+print("\n--- Final Crop Recommendation ---")
+for key, value in result.items():
+    if key == "Warnings" and value:
+        print("Warnings:")
+        for warning in value:
+            print(f"  - {warning}")
+    else:
+        print(f"{key}: {value}")
+
+# Automatically plot the result scores
+CentralCoordinator.plot_scores(result)

models/weather_Analyst.py

@@ -0,0 +1,112 @@
+import sqlite3
+import pandas as pd
+import joblib
+import os
+import logging
+from sklearn.ensemble import RandomForestRegressor
+from sklearn.preprocessing import StandardScaler
+from sklearn.model_selection import train_test_split
+
+# Set up logging
+logging.basicConfig(level=logging.INFO, format='%(asctime)s - %(levelname)s - %(message)s')
+logger = logging.getLogger(__name__)
+
+class WeatherAnalyst:
+
+    def __init__(self, db_path=None):
+        if db_path is None:
+            db_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'database', 'sustainable_farming.db'))
+        self.db_path = db_path
+        # Always use absolute path for models_dir
+        self.models_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'models'))
+
+        if not os.path.exists(self.models_dir):
+            os.makedirs(self.models_dir)
+            logger.info(f"Created models directory at: {self.models_dir}")
+
+        self.scaler = StandardScaler()
+        self.df = None
+        temp_model_path = os.path.join(self.models_dir, 'temp_model.pkl')
+        rain_model_path = os.path.join(self.models_dir, 'rain_model.pkl')
+        scaler_path = os.path.join(self.models_dir, 'weather_scaler.pkl')
+        if os.path.exists(temp_model_path) and os.path.exists(rain_model_path) and os.path.exists(scaler_path):
+            # Models already exist, do not retrain
+            pass
+        else:
+            self._prepare_data()
+            self._train_models()
+
+    def _prepare_data(self):
+        try:
+            with sqlite3.connect(self.db_path) as conn:
+                self.df = pd.read_sql("""
+                    SELECT Soil_pH, Soil_Moisture, Temperature_C, Rainfall_mm,
+                           Fertilizer_Usage_kg, Pesticide_Usage_kg
+                    FROM farmer_advisor
+                """, conn)
+            if self.df.empty:
+                logger.warning("No data found in farmer_advisor table.")
+                raise ValueError("The farmer_advisor table is empty. Please populate it with data.")
+            logger.info(f"Loaded {len(self.df)} rows from farmer_advisor table.")
+        except sqlite3.Error as e:
+            logger.error(f"Database error: {str(e)}")
+            raise sqlite3.Error(f"Failed to connect to database or query data: {str(e)}")
+        except Exception as e:
+            logger.error(f"Error preparing data: {str(e)}")
+            raise
+
+    def _train_models(self):
+        try:
+            features = ['Soil_pH', 'Soil_Moisture', 'Fertilizer_Usage_kg', 'Pesticide_Usage_kg']
+            X = self.df[features]
+            X_scaled = self.scaler.fit_transform(X)
+
+            y_temp = self.df['Temperature_C']
+            y_rain = self.df['Rainfall_mm']
+
+            temp_model = RandomForestRegressor(n_estimators=100, random_state=42)
+            temp_model.fit(X_scaled, y_temp)
+
+            rain_model = RandomForestRegressor(n_estimators=100, random_state=42)
+            rain_model.fit(X_scaled, y_rain)
+
+            temp_model_path = os.path.join(self.models_dir, 'temp_model.pkl')
+            rain_model_path = os.path.join(self.models_dir, 'rain_model.pkl')
+            scaler_path = os.path.join(self.models_dir, 'weather_scaler.pkl')
+
+            # Remove files if they exist to avoid OneDrive/Windows file lock issues
+            for path in [temp_model_path, rain_model_path, scaler_path]:
+                try:
+                    if os.path.exists(path):
+                        os.remove(path)
+                except Exception as e:
+                    logger.warning(f"Could not remove existing model file {path}: {e}")
+
+            joblib.dump(temp_model, temp_model_path)
+            logger.info(f"Saved temperature model at {temp_model_path}")
+
+            joblib.dump(rain_model, rain_model_path)
+            logger.info(f"Saved rainfall model at {rain_model_path}")
+
+            joblib.dump(self.scaler, scaler_path)
+            logger.info(f"Saved scaler at {scaler_path}")
+        except Exception as e:
+            logger.error(f"Error training models: {str(e)}")
+            raise
+
+    def forecast(self, soil_ph, soil_moisture, fertilizer, pesticide):
+        try:
+            temp_model = joblib.load(os.path.join(self.models_dir, 'temp_model.pkl'))
+            rain_model = joblib.load(os.path.join(self.models_dir, 'rain_model.pkl'))
+            scaler = joblib.load(os.path.join(self.models_dir, 'weather_scaler.pkl'))
+
+            input_df = pd.DataFrame([[soil_ph, soil_moisture, fertilizer, pesticide]],
+                                    columns=['Soil_pH', 'Soil_Moisture', 'Fertilizer_Usage_kg', 'Pesticide_Usage_kg'])
+            input_scaled = scaler.transform(input_df)
+
+            predicted_temp = temp_model.predict(input_scaled)[0]
+            predicted_rain = rain_model.predict(input_scaled)[0]
+            return {'temperature': [predicted_temp], 'rainfall': [predicted_rain]}
+        except Exception as e:
+            logger.error(f"Error during forecasting: {str(e)}")
+            raise

models/weather_api.py

@@ -0,0 +1,52 @@
+import requests
+
+API_KEY = "8acd7401e3d1478a87596f7e00e76226"
+BASE_URL = "https://api.openweathermap.org/data/2.5/weather"
+
+def get_current_weather(city_name):
+    """
+    Fetch current weather data for a given city using OpenWeatherMap API.
+    Returns a dictionary with temperature (Celsius) and rainfall (mm, if available).
+    """
+    params = {
+        'q': city_name,
+        'appid': API_KEY,
+        'units': 'metric'
+    }
+    response = requests.get(BASE_URL, params=params)
+    data = response.json()
+    if response.status_code != 200:
+        raise Exception(f"Weather API error: {data.get('message', 'Unknown error')}")
+    temp = data['main']['temp']
+    # Rainfall may not always be present
+    rain = data.get('rain', {}).get('1h', 0.0)
+    return {
+        'temperature': temp,
+        'rainfall': rain
+    } 
+import requests
+
+API_KEY = "8acd7401e3d1478a87596f7e00e76226"
+BASE_URL = "https://api.openweathermap.org/data/2.5/weather"
+
+def get_current_weather(city_name):
+    """
+    Fetch current weather data for a given city using OpenWeatherMap API.
+    Returns a dictionary with temperature (Celsius) and rainfall (mm, if available).
+    """
+    params = {
+        'q': city_name,
+        'appid': API_KEY,
+        'units': 'metric'
+    }
+    response = requests.get(BASE_URL, params=params)
+    data = response.json()
+    if response.status_code != 200:
+        raise Exception(f"Weather API error: {data.get('message', 'Unknown error')}")
+    temp = data['main']['temp']
+    # Rainfall may not always be present
+    rain = data.get('rain', {}).get('1h', 0.0)
+    return {
+        'temperature': temp,
+        'rainfall': rain
+    }