farming-expert

name	farming-expert
version	1.0.0
description	Expert-level precision agriculture, farm management systems, crop monitoring, and agtech
category	domains
tags	["agriculture","farming","precision-agriculture","agtech","crop-management"]
allowed-tools	["Read","Write","Edit"]

Farming Expert

Expert guidance for precision agriculture, farm management systems, crop monitoring, IoT sensors, and agricultural technology.

Core Concepts

Precision Agriculture

• GPS-guided equipment
• Variable rate technology
• Crop monitoring and sensors
• Soil analysis and mapping
• Drone/satellite imagery
• Automated irrigation systems

Farm Management

• Crop planning and rotation
• Resource optimization
• Yield prediction
• Weather forecasting integration
• Equipment maintenance
• Financial management

AgTech Solutions

• IoT sensors (soil, weather)
• Machine learning for yield prediction
• Automated harvesting
• Livestock tracking
• Supply chain integration
• Marketplace platforms

Farm Management System

from dataclasses import dataclass
from typing import List, Optional
from datetime import datetime, timedelta
from enum import Enum

class CropType(Enum):
    WHEAT = "wheat"
    CORN = "corn"
    SOYBEANS = "soybeans"
    RICE = "rice"
    VEGETABLES = "vegetables"

class GrowthStage(Enum):
    PLANTED = "planted"
    GERMINATION = "germination"
    VEGETATIVE = "vegetative"
    FLOWERING = "flowering"
    HARVEST_READY = "harvest_ready"
    HARVESTED = "harvested"

@dataclass
class Field:
    field_id: str
    name: str
    area_hectares: float
    soil_type: str
    coordinates: List[tuple]  # GPS polygon
    irrigation_system: str
    drainage_quality: str

@dataclass
class CropCycle:
    cycle_id: str
    field_id: str
    crop_type: CropType
    variety: str
    planting_date: datetime
    expected_harvest_date: datetime
    growth_stage: GrowthStage
    seed_rate: float
    fertilizer_applied: []
    pesticides_applied: []
    irrigation_schedule: []

 :
    

     ():
        .db = db

     ():
        
        field = .db.get_field(field_id)
        history = .db.get_crop_history(field_id, years=)

        
        rotation_plan = []

        
        
        
        

         year  (years):
            recommended_crop = .recommend_next_crop(field, history, year)
            rotation_plan.append({
                : datetime.now().year + year,
                : recommended_crop,
                : .explain_recommendation(recommended_crop, history)
            })

         rotation_plan

     ():
        
        field = .db.get_field(field_id)
        current_crop = .db.get_current_crop(field_id)

        
        soil_moisture = .get_soil_moisture_data(field_id)
        weather_data = .get_weather_data(field.coordinates)
        ndvi_data = .get_ndvi_from_satellite(field.coordinates)

        
        health_score = .calculate_health_score(
            soil_moisture,
            weather_data,
            ndvi_data,
            current_crop
        )

        alerts = []
         soil_moisture < current_crop.optimal_moisture_min:
            alerts.append({
                : ,
                : ,
                : 
            })

         ndvi_data < :  
            alerts.append({
                : ,
                : ,
                : 
            })

         {
            : field_id,
            : health_score,
            : soil_moisture,
            : ndvi_data,
            : alerts,
            : .generate_recommendations(alerts)
        }

     ():
        
        field = .db.get_field(field_id)
        current_crop = .db.get_current_crop(field_id)

        
        features = {
            : field.area_hectares,
            : field.soil_type,
            : current_crop.variety,
            : (datetime.now() - current_crop.planting_date).days,
            : .get_accumulated_rainfall(field_id),
            : .get_avg_temperature(field_id),
            : (f[]  f  current_crop.fertilizer_applied),
            : .get_avg_ndvi(field_id)
        }

        
        predicted_yield_per_hectare = .yield_model.predict([features])[]
        total_yield = predicted_yield_per_hectare * field.area_hectares

         {
            : field_id,
            : total_yield,
            : predicted_yield_per_hectare,
            : ,
            : current_crop.expected_harvest_date
        }

IoT Sensor Integration

class AgricultureIoT:
    """IoT sensor data collection and analysis"""

    def process_soil_sensor_data(self, sensor_id):
        """Process soil sensor readings"""
        readings = self.db.get_recent_readings(sensor_id, hours=24)

        analysis = {
            'sensor_id': sensor_id,
            'avg_moisture': np.mean([r['moisture'] for r in readings]),
            'avg_temperature': np.mean([r['temperature'] for r in readings]),
            'avg_ph': np.mean([r['ph'] for r in readings]),
            'avg_ec': np.mean([r['ec'] for r in readings]),  # Electrical conductivity
            'nitrogen_level': np.mean([r['nitrogen'] for r in readings]),
            'phosphorus_level': np.mean([r['phosphorus'] for r in readings]),
            'potassium_level': np.mean([r['potassium'] for r in readings])
        }

        # Detect anomalies
        anomalies = []
        if analysis['avg_moisture'] < 20:
            anomalies.append('Low soil moisture - irrigation recommended')
        if analysis[] <   analysis[] > :
            anomalies.append()

        analysis[] = anomalies

         analysis

     ():
        
        field = .db.get_field(field_id)
        soil_moisture = .get_soil_moisture_data(field_id)
        weather_forecast = .get_weather_forecast(field.coordinates, days=)

        
        should_irrigate = 
        duration_minutes = 

        
         soil_moisture < field.moisture_threshold:
            
            expected_rainfall = (day[]  day  weather_forecast)

             expected_rainfall < :  
                should_irrigate = 
                
                moisture_deficit = field.moisture_threshold - soil_moisture
                duration_minutes = (moisture_deficit * field.area_hectares *  / field.irrigation_rate)

         should_irrigate:
            .activate_irrigation(field_id, duration_minutes)

         {
            : field_id,
            : should_irrigate,
            : duration_minutes,
            :   should_irrigate  
        }

Weather and Climate Analysis

class WeatherAnalytics:
    """Weather-based agricultural decisions"""

    def analyze_growing_conditions(self, field_id, date_range):
        """Analyze weather suitability for crops"""
        weather_data = self.get_historical_weather(field_id, date_range)

        # Calculate growing degree days (GDD)
        gdd = sum([
            max(0, (day['temp_max'] + day['temp_min']) / 2 - 10)
            for day in weather_data
        ])

        # Analyze frost risk
        frost_days = len([d for d in weather_data if d['temp_min'] < 0])

        # Water balance
        total_rainfall = sum(d['rainfall_mm'] for d in weather_data)
        total_evapotranspiration = sum(d['et_mm'] for d in weather_data)
        water_deficit = total_evapotranspiration - total_rainfall

        return {
            'growing_degree_days': gdd,
            'frost_days': frost_days,
            'total_rainfall_mm': total_rainfall,
            'water_deficit_mm': water_deficit,
            'avg_temperature': np.mean([d['temp_avg'] for d in weather_data]),
            'suitability_score': .calculate_suitability_score(gdd, frost_days, water_deficit)
        }

     ():
        
        historical_weather = .get_historical_weather(field_id, years=)
        crop_requirements = .get_crop_requirements(crop_type)

        
        
        
        

        optimal_dates = []

         year_data  historical_weather:
             date, conditions  year_data.items():
                score = .score_planting_conditions(
                    conditions,
                    crop_requirements
                )
                optimal_dates.append((date, score))

        
        best_dates = (optimal_dates, key= x: x[], reverse=)[:]

         {
            : {
                : best_dates[-][],
                : best_dates[][]
            },
            : np.mean([d[]  d  best_dates])
        }

Pest and Disease Management

class PestManagement:
    """Pest and disease monitoring and management"""

    def detect_pest_risk(self, field_id):
        """Predict pest pressure"""
        weather_data = self.get_recent_weather(field_id, days=14)
        crop = self.db.get_current_crop(field_id)

        # Environmental factors affecting pests
        avg_temp = np.mean([d['temperature'] for d in weather_data])
        avg_humidity = np.mean([d['humidity'] for d in weather_data])
        rainfall = sum(d['rainfall_mm'] for d in weather_data)

        risk_factors = {
            'temperature_risk': self.assess_temp_risk(avg_temp, crop.crop_type),
            'humidity_risk': self.assess_humidity_risk(avg_humidity),
            'rainfall_risk': self.assess_rainfall_risk(rainfall)
        }

        overall_risk = sum(risk_factors.values()) / len(risk_factors)

        recommendations = []
        if overall_risk > 0.7:
            recommendations.append('Scout fields for pest activity')
            recommendations.append('Consider preventive treatment')
        elif overall_risk > 0.5:
            recommendations.append('Increase monitoring frequency')

        return {
            'field_id': field_id,
            'overall_risk_score': overall_risk,
            :   overall_risk >     overall_risk >   ,
            : risk_factors,
            : recommendations
        }

     ():
        
        
        

        predictions = .disease_detection_model.predict(image_data)

         {
            : predictions[],
            : predictions[],
            : predictions[],
            : .get_treatment_plan(predictions[])
        }

Best Practices

• Use precision agriculture techniques
• Implement crop rotation
• Monitor soil health regularly
• Integrate weather data for decisions
• Use IoT sensors for real-time monitoring
• Apply variable rate technology
• Optimize water usage
• Practice integrated pest management
• Track field-level profitability
• Use data-driven decision making
• Maintain equipment properly
• Follow sustainable practices

Anti-Patterns

❌ Over-application of inputs ❌ Ignoring soil health ❌ No crop rotation ❌ Manual data collection only ❌ Ignoring weather forecasts ❌ Reactive instead of proactive management ❌ No yield analysis

Resources

• Precision Agriculture: https://www.ispag.org/
• FAO Agricultural Data: http://www.fao.org/faostat/
• Crop Science Society: https://www.crops.org/
• Agricultural IoT: https://www.iot-agriculturet.com/