Upload 11 files

agents/agent_setup.py

@@ -0,0 +1,452 @@
+
+import sys
+import os
+# Add the 'models' directory to the Python path
+sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'models')))
+# Importing necessary autogen classes and SQLite connector
+from autogen import AssistantAgent, GroupChat, GroupChatManager
+import sqlite3
+import pandas as pd
+from farmer_advisor import FarmerAdvisor
+from market_Researcher import MarketResearcher
+from weather_Analyst import WeatherAnalyst
+from sustainability_Expert import SustainabilityExpert
+import re  # For parsing market prices from the message
+
+# Custom AssistantAgent class to override generate_reply
+class CustomAssistantAgent(AssistantAgent):
+    def __init__(self, name, system_message, llm_config):
+        super().__init__(name=name, system_message=system_message, llm_config=llm_config)
+        # Instantiate the agent classes
+        self.farmer_advisor = FarmerAdvisor()
+        self.market_researcher = MarketResearcher()
+        db_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'database', 'sustainable_farming.db'))
+        self.weather_analyst = WeatherAnalyst(db_path=db_path)
+        self.sustainability_expert = SustainabilityExpert()
+        # Simulated farm and market inputs
+        self.simulated_inputs = {
+            'soil_ph': 6.5,  # Neutral soil pH
+            'soil_moisture': 30.0,  # Percentage
+            'fertilizer': 50.0,  # kg/ha
+            'pesticide': 2.0,  # kg/ha
+            'crop_yield': 3.0,  # ton/ha
+            'temperature': 25.0,  # Celsius (initial placeholder, updated by WeatherAnalyst)
+            'rainfall': 50.0,  # mm (initial placeholder, updated by WeatherAnalyst)
+            '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
+            }
+        }
+        self.sustainability_metrics = {}  # To store overall sustainability scores and new metrics
+        self.final_result = None  # To store the final recommendation and chart data
+
+    def generate_reply(self, messages=None, sender=None):
+        if messages is None and sender is not None:
+            messages = self.chat_messages.get(sender, [])
+
+        # Responses for each agent
+        if self.name == "FarmerAdvisor":
+            response = self.farmer_advisor_response(messages)
+        elif self.name == "MarketResearcher":
+            response = self.market_researcher_response(messages)
+        elif self.name == "WeatherAnalyst":
+            response = self.weather_analyst_response(messages)
+        elif self.name == "SustainabilityExpert":
+            response = self.sustainability_expert_response(messages)
+        elif self.name == "CentralCoordinator":
+            response = self.central_coordinator_logic(messages, sender)
+        else:
+            response = "No response available."
+
+        # Debug: Log the response
+        print(f"{self.name} response: {response}")
+
+        # Ensure the response is a non-empty string (or dict for CentralCoordinator)
+        if response is None or (isinstance(response, str) and not response.strip()):
+            response = f"{self.name}: No valid response generated."
+        
+        return response
+
+    def farmer_advisor_response(self, messages):
+        initial_message = next((msg["content"] for msg in messages if msg["name"] == "CentralCoordinator"), "")
+        if "hectare farm with" in initial_message:
+            parts = initial_message.split("suggest crops based on a ")[1].split(" farm with ")
+            land_size = float(parts[0].split("-hectare")[0])
+            soil_type = parts[1].split(" soil and a preference for ")[0].lower()
+            crop_preference = parts[1].split(" soil and a preference for ")[1].split(".")[0].lower()
+
+            # Map soil type to soil pH (simplified mapping)
+            soil_ph_mapping = {"sandy": 6.0, "loamy": 6.5, "clay": 7.0}
+            self.simulated_inputs['soil_ph'] = soil_ph_mapping.get(soil_type, 6.5)
+
+            # Use WeatherAnalyst's forecast for temperature and rainfall
+            weather_forecast = self.weather_analyst.forecast(
+                self.simulated_inputs['soil_ph'],
+                self.simulated_inputs['soil_moisture'],
+                self.simulated_inputs['fertilizer'],
+                self.simulated_inputs['pesticide']
+            )
+            self.simulated_inputs['temperature'] = weather_forecast['temperature'][0]
+            self.simulated_inputs['rainfall'] = weather_forecast['rainfall'][0]
+
+            # Recommend crops
+            recommended_crop = self.farmer_advisor.recommend(
+                soil_ph=self.simulated_inputs['soil_ph'],
+                soil_moisture=self.simulated_inputs['soil_moisture'],
+                temp=self.simulated_inputs['temperature'],
+                rainfall=self.simulated_inputs['rainfall'],
+                fertilizer=self.simulated_inputs['fertilizer'],
+                pesticide=self.simulated_inputs['pesticide'],
+                crop_yield=self.simulated_inputs['crop_yield']
+            )
+            # Suggest a second crop based on crop preference
+            crop_preference_crops = {
+                "grains": ["wheat", "corn", "rice", "soybean"],
+                "vegetables": ["carrots", "tomatoes"],
+                "fruits": ["apples", "oranges"]
+            }
+            suggested_crops = crop_preference_crops.get(crop_preference, ["wheat", "corn"])
+            if recommended_crop.lower() not in [crop.lower() for crop in suggested_crops]:
+                suggested_crops[0] = recommended_crop.lower()
+            return f"Based on a {land_size}-hectare farm with {soil_type} soil and a preference for {crop_preference}, I suggest planting {suggested_crops[0]} and {suggested_crops[1]}."
+        return "No farm inputs provided to suggest crops."
+
+    def market_researcher_response(self, messages):
+        farmer_response = next((msg["content"] for msg in messages if msg["name"] == "FarmerAdvisor"), "")
+        if "suggest planting" in farmer_response:
+            crops = farmer_response.split("suggest planting ")[1].split(" and ")
+            crops = [crop.strip(".") for crop in crops]
+            market_insights = []
+            for crop in crops:
+                try:
+                    predicted_price = self.market_researcher.forecast(crop, self.simulated_inputs['market_features'])[0]
+                    market_insights.append(f"{crop} is expected to have a market price of ${predicted_price:.2f} per ton")
+                except ValueError as e:
+                    market_insights.append(f"No market data available for {crop}")
+            return ", and ".join(market_insights) + "."
+        return "No crops suggested to provide market insights."
+
+    def weather_analyst_response(self, messages):
+        temp = self.simulated_inputs['temperature']
+        rainfall = self.simulated_inputs['rainfall']
+        return f"For the next 3 months, expect a temperature of {temp:.1f}°C and rainfall of {rainfall:.1f} mm."
+
+    def sustainability_expert_response(self, messages):
+        farmer_response = next((msg["content"] for msg in messages if msg["name"] == "FarmerAdvisor"), "")
+        if "suggest planting" in farmer_response:
+            crops = farmer_response.split("suggest planting ")[1].split(" and ")
+            crops = [crop.strip(".") for crop in crops]
+
+            # Compute sustainability scores for each crop
+            sustainability_notes = []
+            self.sustainability_metrics = {}
+
+            for crop in crops:
+                try:
+                    scores_tuple = self.sustainability_expert.evaluate(
+                        [crop],
+                        soil_ph=self.simulated_inputs['soil_ph'],
+                        soil_moisture=self.simulated_inputs['soil_moisture'],
+                        rainfall=self.simulated_inputs['rainfall'],
+                        fertilizer=self.simulated_inputs['fertilizer'],
+                        pesticide=self.simulated_inputs['pesticide'],
+                        crop_yield=self.simulated_inputs['crop_yield']
+                    )
+                    scores = scores_tuple[1]  # Dictionary with sustainability, carbon, water, erosion scores
+                except Exception as e:
+                    return f"Error evaluating sustainability: {str(e)}"
+
+                self.sustainability_metrics[crop] = {
+                    'sustainability_score': scores['sustainability'],
+                    'carbon_score': scores['carbon'],
+                    'water_score': scores['water'],
+                    'erosion_score': scores['erosion']
+                }
+
+                sustainability_notes.append(
+                    f"{crop} has a predicted sustainability score of {scores['sustainability']:.2f} "
+                    f"(Carbon Footprint: {scores['carbon']:.2f}, Water: {scores['water']:.2f}, Erosion: {scores['erosion']:.2f})."
+                )
+
+            return " ".join(sustainability_notes)
+        return "No crops suggested to evaluate sustainability."
+
+    def central_coordinator_logic(self, messages, sender):
+        # Collect responses from all agents
+        agent_responses = {}
+        for message in messages:
+            sender_name = message.get("name")
+            content = message.get("content")
+            if sender_name and content and sender_name != "CentralCoordinator":
+                agent_responses[sender_name] = content
+
+        # Extract crops from FarmerAdvisor
+        crops = agent_responses.get("FarmerAdvisor", "").split("suggest planting ")[1].split(" and ")
+        crops = [crop.strip(".") for crop in crops]
+
+        # Extract market, weather, and sustainability info
+        market_info = agent_responses.get("MarketResearcher", "")
+        weather_info = agent_responses.get("WeatherAnalyst", "")
+        sustainability_info = agent_responses.get("SustainabilityExpert", "")
+
+        # Parse market prices from MarketResearcher's response
+        market_predictions = {}
+        for crop in crops:
+            pattern = rf"{crop} is expected to have a market price of \$([\d\.]+) per ton"
+            match = re.search(pattern, market_info)
+            if match:
+                market_predictions[crop] = float(match.group(1))
+            else:
+                market_predictions[crop] = 0.0  # Default if price not found
+
+        # Parse sustainability scores from SustainabilityExpert's response
+        sustainability_scores = {}
+        for crop in crops:
+            pattern = rf"{crop} has a predicted sustainability score of ([\d\.]+) \(Carbon Footprint: ([\d\.]+), Water: ([\d\.]+), Erosion: ([\d\.]+)\)"
+            match = re.search(pattern, sustainability_info)
+            if match:
+                sustainability_score = float(match.group(1))
+                carbon_score = float(match.group(2))
+                water_score = float(match.group(3))
+                erosion_score = float(match.group(4))
+                sustainability_scores[crop] = {
+                    'sustainability_score': sustainability_score,
+                    'carbon_score': carbon_score,
+                    'water_score': water_score,
+                    'erosion_score': erosion_score
+                }
+            else:
+                sustainability_scores[crop] = {
+                    'sustainability_score': 0.5,
+                    'carbon_score': 0.0,
+                    'water_score': 0.0,
+                    'erosion_score': 0.0
+                }
+
+        # Weighted scoring system
+        weights = {
+            "market": 0.25,         # 25%
+            "weather": 0.20,        # 20%
+            "sustainability": 0.20, # 20%
+            "carbon": 0.15,         # 15%
+            "water": 0.10,          # 10%
+            "erosion": 0.10         # 10%
+        }
+        crop_scores = {}
+
+        for crop in crops:
+            # Market Score (Profitability): Based on predicted price
+            market_score = 0.5  # Default
+            predicted_price = market_predictions.get(crop, 0.0)
+            market_score = min(predicted_price / 1000.0, 1.0)
+
+            # Weather Score (Suitability): Based on temperature and rainfall
+            temp = float(weather_info.split("temperature of ")[1].split("°C")[0])
+            rainfall = float(weather_info.split("rainfall of ")[1].split(" mm")[0])
+            weather_score = 1 - abs(temp - self.simulated_inputs['temperature']) / 50 - abs(rainfall - self.simulated_inputs['rainfall']) / 100
+            weather_score = max(0, round(weather_score, 2))
+
+            # Sustainability Scores
+            sustainability_metrics = sustainability_scores.get(crop, {
+                'sustainability_score': 0.5,
+                'carbon_score': 0.0,
+                'water_score': 0.0,
+                'erosion_score': 0.0
+            })
+            sustainability_score = sustainability_metrics['sustainability_score']
+            carbon_score = sustainability_metrics['carbon_score']
+            water_score = sustainability_metrics['water_score']
+            erosion_score = sustainability_metrics['erosion_score']
+
+            # Total score
+            total_score = (
+                weights["market"] * market_score +
+                weights["weather"] * weather_score +
+                weights["sustainability"] * sustainability_score +
+                weights["carbon"] * carbon_score +
+                weights["water"] * water_score +
+                weights["erosion"] * erosion_score
+            )
+            crop_scores[crop] = {
+                'total_score': total_score,
+                'market_score': market_score,
+                'weather_score': weather_score,
+                'sustainability_score': sustainability_score,
+                'carbon_score': carbon_score,
+                'water_score': water_score,
+                'erosion_score': erosion_score,
+                'predicted_temperature': temp,
+                'predicted_rainfall': rainfall
+            }
+
+        # Rank crops by total score and remove duplicates
+        seen_crops = set()
+        unique_crop_scores = []
+        for crop, scores in sorted(crop_scores.items(), key=lambda x: x[1]['total_score'], reverse=True):
+            if crop not in seen_crops:
+                seen_crops.add(crop)
+                unique_crop_scores.append((crop, scores))
+
+        # Generate recommendation with detailed rationale
+        recommendations = []
+        for crop, scores in unique_crop_scores:
+            market_rationale = f"market score: {scores['market_score']:.2f} (${market_predictions.get(crop, 0.0):.2f}/ton)"
+            weather_rationale = f"weather suitability: {scores['weather_score']:.2f}"
+            sustainability_rationale = f"sustainability: {scores['sustainability_score']:.2f}"
+            carbon_rationale = f"carbon footprint: {scores['carbon_score']:.2f}"
+            water_rationale = f"water: {scores['water_score']:.2f}"
+            erosion_rationale = f"erosion: {scores['erosion_score']:.2f}"
+            rationale = (f"Plant {crop}: {market_rationale}, {weather_rationale}, {sustainability_rationale}, "
+                        f"{carbon_rationale}, {water_rationale}, {erosion_rationale} (Final Score: {scores['total_score']:.2f})")
+            recommendations.append(rationale)
+
+        # Combine into final recommendation
+        final_recommendation = "Recommendations:\n" + "\n".join(recommendations) + f"\n\nDetails:\nMarket Insights: {market_info}\nWeather Forecast: {weather_info}\nSustainability Notes: {sustainability_info}"
+
+        # Generate pie chart data for visualization in Streamlit
+        chart_data = []
+        for crop, scores in unique_crop_scores:
+            chart_data.append({
+                'crop': crop,
+                'labels': ['Market Score', 'Weather Suitability Score', 'Sustainability Score',
+                           'Carbon Footprint Score', 'Water Score', 'Erosion Score', 'Final Score'],
+                'values': [
+                    scores['market_score'],
+                    scores['weather_score'],
+                    scores['sustainability_score'],
+                    scores['carbon_score'],
+                    scores['water_score'],
+                    scores['erosion_score'],
+                    scores['total_score']
+                ]
+            })
+
+        # Store in SQLite with new columns for all scores
+        db_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'database', 'sustainable_farming.db'))
+        with sqlite3.connect(db_path) as conn:
+            cursor = conn.cursor()
+            cursor.execute("""
+                CREATE TABLE IF NOT EXISTS recommendations (
+                    id INTEGER PRIMARY KEY AUTOINCREMENT,
+                    crop TEXT,
+                    score REAL,
+                    rationale TEXT,
+                    market_score REAL,
+                    weather_score REAL,
+                    sustainability_score REAL,
+                    carbon_score REAL,
+                    water_score REAL,
+                    erosion_score REAL,
+                    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+                )
+            """)
+            for crop, scores in unique_crop_scores:
+                cursor.execute(
+                    "INSERT INTO recommendations (crop, score, rationale, market_score, weather_score, sustainability_score, carbon_score, water_score, erosion_score) "
+                    "VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)",
+                    (
+                        crop,
+                        scores['total_score'],
+                        f"Plant {crop}: market score: {scores['market_score']:.2f}, weather suitability: {scores['weather_score']:.2f}, sustainability: {scores['sustainability_score']:.2f}",
+                        scores['market_score'],
+                        scores['weather_score'],
+                        scores['sustainability_score'],
+                        scores['carbon_score'],
+                        scores['water_score'],
+                        scores['erosion_score']
+                    )
+                )
+            conn.commit()
+
+        # Store the full result in the instance variable
+        self.final_result = {
+            'recommendation': final_recommendation,
+            'chart_data': chart_data
+        }
+
+        # Return only the recommendation string as the chat message
+        return final_recommendation
+
+# Define the agents using the custom class
+farmer_advisor = CustomAssistantAgent(
+    name="FarmerAdvisor",
+    system_message="I am the Farmer Advisor. I process farmer inputs to suggest suitable crops.",
+    llm_config=False
+)
+
+market_researcher = CustomAssistantAgent(
+    name="MarketResearcher",
+    system_message="I am the Market Researcher. I analyze market trends to suggest profitable crops.",
+    llm_config=False
+)
+
+weather_analyst = CustomAssistantAgent(
+    name="WeatherAnalyst",
+    system_message="I am the Weather Analyst. I predict weather conditions based on farm inputs.",
+    llm_config=False
+)
+
+sustainability_expert = CustomAssistantAgent(
+    name="SustainabilityExpert",
+    system_message="I am the Sustainability Expert. I evaluate crops for sustainability.",
+    llm_config=False
+)
+
+central_coordinator = CustomAssistantAgent(
+    name="CentralCoordinator",
+    system_message="I am the Central Coordinator. I integrate agent outputs to provide recommendations.",
+    llm_config=False
+)
+
+# Define a custom speaker selection function
+def custom_select_speaker(last_speaker, groupchat):
+    agents = [farmer_advisor, market_researcher, weather_analyst, sustainability_expert, central_coordinator]
+    if last_speaker is None:
+        return agents[0]
+    last_index = agents.index(last_speaker)
+    next_index = (last_index + 1) % len(agents)
+    return agents[next_index]
+
+# Set up the group chat for agent interactions
+group_chat = GroupChat(
+    agents=[farmer_advisor, market_researcher, weather_analyst, sustainability_expert, central_coordinator],
+    messages=[],
+    max_round=6  # Already set to 6 to allow CentralCoordinator to respond
+)
+
+group_chat.select_speaker = custom_select_speaker
+
+group_chat_manager = GroupChatManager(
+    groupchat=group_chat,
+    llm_config=False
+)
+
+# Function to initiate the group chat with dynamic farmer inputs and return the recommendation
+def run_agent_collaboration(land_size, soil_type, crop_preference):
+    initial_message = (
+        f"Let’s generate a farming recommendation. "
+        f"FarmerAdvisor, please suggest crops based on a {land_size}-hectare farm with {soil_type.lower()} soil "
+        f"and a preference for {crop_preference.lower()}. "
+        f"MarketResearcher, provide market insights for those crops. "
+        f"WeatherAnalyst, predict weather for the next 3 months. "
+        f"SustainabilityExpert, evaluate the sustainability of the suggested crops."
+    )
+    # Initiate the chat
+    central_coordinator.initiate_chat(
+        group_chat_manager,
+        message={"content": initial_message, "role": "user"}
+    )
+    # Retrieve the final result from the CentralCoordinator instance
+    result = central_coordinator.final_result
+    if result is None:
+        raise ValueError("No recommendation generated by CentralCoordinator.")
+    return result
+
+if __name__ == "__main__":
+    result = run_agent_collaboration(land_size=8, soil_type="Loamy", crop_preference="Grains")
+    print(result['recommendation'])

agents/init_db.py

@@ -0,0 +1,106 @@
+import sqlite3
+import os
+
+def initialize_db():
+    """
+    Initialize the SQLite database with necessary tables and sample data if they don't exist.
+    """
+    # Define the database path relative to the project root
+    db_path = os.path.abspath(os.path.join(os.path.dirname(__file__), '..', 'database', 'sustainable_farming.db'))
+    
+    # Create the database directory if it doesn't exist
+    os.makedirs(os.path.dirname(db_path), exist_ok=True)
+    
+    with sqlite3.connect(db_path) as conn:
+        cursor = conn.cursor()
+        
+        # Create farmer_advisor table
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS farmer_advisor (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                Soil_pH REAL,
+                Soil_Moisture REAL,
+                Temperature_C REAL,
+                Rainfall_mm REAL,
+                Fertilizer_Usage_kg REAL,
+                Pesticide_Usage_kg REAL,
+                Crop_Yield_ton REAL,
+                Crop_Type TEXT,
+                Sustainability_Score REAL
+            )
+        """)
+        
+        # Create market_researcher table
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS market_researcher (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                Product TEXT,
+                Market_Price_per_ton REAL,
+                Demand_Index REAL,
+                Supply_Index REAL,
+                Competitor_Price_per_ton REAL,
+                Economic_Indicator REAL,
+                Weather_Impact_Score REAL,
+                Seasonal_Factor TEXT,
+                Consumer_Trend_Index REAL
+            )
+        """)
+        
+        # Create recommendations table
+        cursor.execute("""
+            CREATE TABLE IF NOT EXISTS recommendations (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                crop TEXT,
+                score REAL,
+                rationale TEXT,
+                market_score REAL,
+                weather_score REAL,
+                sustainability_score REAL,
+                carbon_score REAL,
+                water_score REAL,
+                erosion_score REAL,
+                timestamp DATETIME DEFAULT CURRENT_TIMESTAMP
+            )
+            
+        """)
+        cursor.execute('''CREATE TABLE IF NOT EXISTS users (
+            id INTEGER PRIMARY KEY AUTOINCREMENT,
+            username TEXT UNIQUE,
+            farm_name TEXT,
+            profile_picture TEXT,
+            created_at TEXT
+        )''')
+        
+        # Check if farmer_advisor table is empty and populate with sample data
+        cursor.execute("SELECT COUNT(*) FROM farmer_advisor")
+        if cursor.fetchone()[0] == 0:
+            sample_data = [
+                (6.5, 30.0, 25.0, 50.0, 50.0, 2.0, 3.0, "tomatoes", 0.75),
+                (6.0, 25.0, 24.0, 40.0, 45.0, 1.8, 2.8, "carrots", 0.68),
+                (7.0, 35.0, 26.0, 60.0, 55.0, 2.2, 3.2, "wheat", 0.70),
+                (6.2, 28.0, 23.0, 45.0, 48.0, 1.9, 2.9, "corn", 0.72)
+            ]
+            cursor.executemany("""
+                INSERT INTO farmer_advisor (Soil_pH, Soil_Moisture, Temperature_C, Rainfall_mm,
+                                            Fertilizer_Usage_kg, Pesticide_Usage_kg, Crop_Yield_ton,
+                                            Crop_Type, Sustainability_Score)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, sample_data)
+        
+        # Check if market_researcher table is empty and populate with sample data
+        cursor.execute("SELECT COUNT(*) FROM market_researcher")
+        if cursor.fetchone()[0] == 0:
+            sample_data = [
+                ("tomatoes", 950.0, 0.6, 0.4, 900.0, 0.8, 0.7, "High", 0.6),
+                ("carrots", 800.0, 0.5, 0.5, 850.0, 0.7, 0.6, "Medium", 0.5),
+                ("wheat", 600.0, 0.4, 0.6, 650.0, 0.9, 0.8, "Low", 0.7),
+                ("corn", 700.0, 0.5, 0.5, 720.0, 0.8, 0.7, "Medium", 0.6)
+            ]
+            cursor.executemany("""
+                INSERT INTO market_researcher (Product, Market_Price_per_ton, Demand_Index, Supply_Index,
+                                               Competitor_Price_per_ton, Economic_Indicator,
+                                               Weather_Impact_Score, Seasonal_Factor, Consumer_Trend_Index)
+                VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)
+            """, sample_data)
+        
+        conn.commit()

database/load_data.py

@@ -0,0 +1,16 @@
+import pandas as pd
+import sqlite3
+
+# Load CSV files
+farmer_df = pd.read_csv('data/farmer_advisor_dataset.csv')
+market_df = pd.read_csv('data/market_researcher_dataset.csv')
+
+# Connect to SQLite DB
+conn = sqlite3.connect('database/sustainable_farming.db')
+
+# Load into SQLite tables
+farmer_df.to_sql('farmer_advisor', conn, if_exists='replace', index=False)
+market_df.to_sql('market_researcher', conn, if_exists='replace', index=False)
+
+conn.close()
+print("CSV data loaded into database.")

database/preprocess_data.py

@@ -0,0 +1,42 @@
+import sqlite3
+import pandas as pd
+from sklearn.preprocessing import MinMaxScaler
+
+# Connect to database
+conn = sqlite3.connect('sustainable_farming.db')
+
+### === Farmer Data Cleaning === ###
+farmer_df = pd.read_sql_query("SELECT * FROM farmer_advisor", conn)
+
+farmer_scaler = MinMaxScaler()
+farmer_columns_to_normalize = [
+    'Soil_pH', 'Soil_Moisture', 'Temperature_C', 'Rainfall_mm',
+    'Fertilizer_Usage_kg', 'Pesticide_Usage_kg', 'Crop_Yield_ton', 'Sustainability_Score'
+]
+farmer_df[farmer_columns_to_normalize] = farmer_scaler.fit_transform(farmer_df[farmer_columns_to_normalize])
+
+farmer_df.to_sql('farmer_advisor_normalized', conn, if_exists='replace', index=False)
+print("✅ Farmer data normalized and saved.")
+
+
+### === Market Data Cleaning === ###
+market_df = pd.read_sql_query("SELECT * FROM market_researcher", conn)
+
+market_scaler = MinMaxScaler()
+market_columns_to_normalize = [
+    'Market_Price_per_ton',
+    'Demand_Index',
+    'Supply_Index',
+    'Competitor_Price_per_ton',
+    'Economic_Indicator',
+    'Weather_Impact_Score',
+    'Consumer_Trend_Index'
+]
+
+market_df[market_columns_to_normalize] = market_scaler.fit_transform(market_df[market_columns_to_normalize])
+
+# Keep 'Product' and 'Seasonal_Factor' as-is
+market_df.to_sql('market_researcher_normalized', conn, if_exists='replace', index=False)
+print("✅ Market data normalized and saved.")
+
+conn.close()

database/verify.py

@@ -0,0 +1,9 @@
+import sqlite3
+
+conn = sqlite3.connect('sustainable_farming.db')
+cursor = conn.cursor()
+
+cursor.execute("SELECT * FROM market_researcher_normalized where Market_ID = 1")
+print(cursor.fetchall())
+
+conn.close()