updated

mcp_server.py

@@ -90,7 +90,23 @@ class WeedPressureAnalyzer:
 analyzer = WeedPressureAnalyzer()
 
 def analyze_herbicide_trends(year_start, year_end, plot_filter):
-    """Analyze herbicide usage trends over time."""
+    """
+    Analyze herbicide usage trends over time by calculating IFT (Treatment Frequency Index).
+    
+    This tool calculates the IFT (Indice de Fréquence de Traitement) for herbicides, which represents
+    the number of herbicide applications per hectare. It provides visualizations and statistics to
+    understand weed pressure evolution over time.
+    
+    Args:
+        year_start (int): Starting year for analysis (2014-2025)
+        year_end (int): Ending year for analysis (2014-2025) 
+        plot_filter (str): Specific plot name or "Toutes" for all plots
+        
+    Returns:
+        tuple: (plotly_figure, markdown_summary)
+            - plotly_figure: Interactive line chart showing IFT evolution by plot and year
+            - markdown_summary: Detailed statistics including mean/max IFT, risk distribution
+    """
     try:
         # Créer la liste des années à partir des deux sliders
         start_year = int(year_start)
@@ -181,7 +197,25 @@ def analyze_herbicide_trends(year_start, year_end, plot_filter):
         return None, error_msg
 
 def predict_future_weed_pressure():
-    """Predict weed pressure for the next 3 years."""
+    """
+    Predict weed pressure for the next 3 years (2025-2027) using linear regression on historical IFT data.
+    
+    This tool uses historical herbicide IFT data to predict future weed pressure. It applies linear
+    regression to each plot's IFT evolution over time and extrapolates to 2025-2027. Risk levels are
+    classified as: Faible (IFT < 1.0), Modéré (1.0 ≤ IFT < 2.0), Élevé (IFT ≥ 2.0).
+    
+    Prediction Method:
+    1. Calculate historical IFT for each plot/year combination
+    2. Apply linear regression: IFT = slope × year + intercept
+    3. Extrapolate to target years 2025-2027
+    4. Classify risk levels based on predicted IFT values
+    5. Include recent crop history and average historical IFT for context
+    
+    Returns:
+        tuple: (plotly_figure, markdown_summary)
+            - plotly_figure: Bar chart showing predicted IFT by plot and year with risk color coding
+            - markdown_summary: Risk distribution statistics and interpretation
+    """
     try:
         predictions = analyzer.predict_weed_pressure()
         
@@ -215,7 +249,29 @@ def predict_future_weed_pressure():
         return None, f"Erreur: {str(e)}"
 
 def recommend_sensitive_crop_plots():
-    """Recommend plots for sensitive crops."""
+    """
+    Recommend plots suitable for sensitive crops (pois, haricot) based on predicted weed pressure.
+    
+    This tool identifies plots with low predicted weed pressure (IFT < 1.0) and calculates a
+    recommendation score to rank them for sensitive crop cultivation.
+    
+    Recommendation Method:
+    1. Get predicted IFT for 2025-2027 from predict_future_weed_pressure()
+    2. Filter plots with risk_level = "Faible" (IFT < 1.0)
+    3. Calculate recommendation_score = 100 - (predicted_ift × 30)
+    4. Sort plots by recommendation score (higher = better)
+    5. Include recent crop history and historical average IFT for context
+    
+    Recommendation Score:
+    - 100-70: Excellent for sensitive crops
+    - 70-50: Good for sensitive crops with monitoring
+    - 50-0: Requires careful management
+    
+    Returns:
+        tuple: (plotly_figure, markdown_summary)
+            - plotly_figure: Scatter plot showing predicted IFT vs recommendation score
+            - markdown_summary: Top recommended plots with scores and criteria
+    """
     try:
         predictions = analyzer.predict_weed_pressure()
         
@@ -253,34 +309,90 @@ def recommend_sensitive_crop_plots():
     except Exception as e:
         return None, f"Erreur: {str(e)}"
 
-def generate_technical_alternatives(herbicide_family):
-    """Generate technical alternatives."""
-    summary = f"""
-🔄 **Alternatives aux {herbicide_family}**
+def explore_raw_data(year_start, year_end, plot_filter, crop_filter, intervention_filter):
+    """
+    Explore raw agricultural intervention data with filtering capabilities.
+    
+    This tool provides access to the raw dataset from the Station Expérimentale de Kerguéhennec
+    (2014-2025) with filtering options to explore specific subsets of data.
+    
+    Args:
+        year_start (int): Starting year for filtering (2014-2025)
+        year_end (int): Ending year for filtering (2014-2025)
+        plot_filter (str): Specific plot name or "Toutes" for all plots
+        crop_filter (str): Specific crop type or "Toutes" for all crops
+        intervention_filter (str): Specific intervention type or "Toutes" for all interventions
+        
+    Returns:
+        tuple: (plotly_figure, markdown_summary)
+            - plotly_figure: Interactive data table or visualization
+            - markdown_summary: Data summary with statistics and filtering info
+    """
+    try:
+        # Charger les données
+        df = analyzer.load_data()
+        
+        # Appliquer les filtres
+        if year_start and year_end:
+            df = df[(df['year'] >= year_start) & (df['year'] <= year_end)]
+        
+        if plot_filter and plot_filter != "Toutes":
+            df = df[df['plot_name'] == plot_filter]
+            
+        if crop_filter and crop_filter != "Toutes":
+            df = df[df['crop_type'] == crop_filter]
+            
+        if intervention_filter and intervention_filter != "Toutes":
+            df = df[df['intervention_type'] == intervention_filter]
+        
+        if len(df) == 0:
+            return None, "Aucune donnée trouvée avec les filtres sélectionnés."
+        
+        # Créer un résumé des données
+        summary = f"""
+📊 **Exploration des Données Brutes**
 
-**🚜 Alternatives Mécaniques:**
-• Faux-semis répétés avant implantation
-• Binage mécanique en inter-rang
-• Herse étrille en post-levée précoce
+**Filtres appliqués:**
+- Période: {year_start}-{year_end}
+- Parcelle: {plot_filter}
+- Culture: {crop_filter}
+- Type d'intervention: {intervention_filter}
 
-**🌾 Alternatives Culturales:**
-• Rotation longue avec prairie temporaire
-• Cultures intermédiaires piège à nitrates
-• Densité de semis optimisée
+**Statistiques:**
+- Nombre total d'enregistrements: {len(df):,}
+- Nombre de parcelles: {df['plot_name'].nunique()}
+- Nombre d'années: {df['year'].nunique()}
+- Types de cultures: {df['crop_type'].nunique()}
+- Types d'interventions: {df['intervention_type'].nunique()}
 
-**🧪 Alternatives Biologiques:**
-• Stimulateurs de défenses naturelles
-• Extraits végétaux (huiles essentielles)
-• Bioherbicides à base de champignons
+**Répartition par année:**
+{df['year'].value_counts().sort_index().to_string()}
 
-**📋 Plan d'Action:**
-1. Tester sur petites surfaces
-2. Former les équipes
-3. Suivre l'efficacité
-4. Documenter les résultats
-    """
-    
-    return summary
+**Top 10 parcelles:**
+{df['plot_name'].value_counts().head(10).to_string()}
+
+**Top 10 cultures:**
+{df['crop_type'].value_counts().head(10).to_string()}
+
+**Top 10 interventions:**
+{df['intervention_type'].value_counts().head(10).to_string()}
+        """
+        
+        # Créer une visualisation des données
+        if len(df) > 0:
+            # Graphique des interventions par année
+            yearly_counts = df.groupby('year').size().reset_index(name='count')
+            fig = px.bar(yearly_counts, x='year', y='count', 
+                        title=f'Nombre d\'interventions par année ({year_start}-{year_end})',
+                        labels={'count': 'Nombre d\'interventions', 'year': 'Année'})
+            
+            fig.update_layout(height=400)
+            return fig, summary
+        else:
+            return None, summary
+            
+    except Exception as e:
+        return None, f"Erreur lors de l'exploration des données: {str(e)}"
 
 def get_available_plots():
     """Get available plots."""
@@ -292,6 +404,26 @@ def get_available_plots():
         print(f"Erreur lors du chargement des parcelles: {e}")
         return ["Toutes", "Champ ferme Bas", "Etang Milieu", "Lann Chebot"]
 
+def get_available_crops():
+    """Get available crop types."""
+    try:
+        df = analyzer.load_data()
+        crops = sorted(df['crop_type'].dropna().unique().tolist())
+        return ["Toutes"] + crops
+    except Exception as e:
+        print(f"Erreur lors du chargement des cultures: {e}")
+        return ["Toutes", "blé tendre hiver", "pois de conserve", "haricot mange-tout industrie"]
+
+def get_available_interventions():
+    """Get available intervention types."""
+    try:
+        df = analyzer.load_data()
+        interventions = sorted(df['intervention_type'].dropna().unique().tolist())
+        return ["Toutes"] + interventions
+    except Exception as e:
+        print(f"Erreur lors du chargement des interventions: {e}")
+        return ["Toutes", "Traitement et protection des cultures", "Fertilisation", "Travail et Entretien du sol"]
+
 # Create Gradio Interface
 def create_mcp_interface():
     with gr.Blocks(title="🚜 Analyse Pression Adventices", theme=gr.themes.Soft()) as demo:
@@ -304,6 +436,14 @@ def create_mcp_interface():
         with gr.Tabs():
             with gr.Tab("📈 Analyse Tendances"):
                 gr.Markdown("### Analyser l'évolution de l'IFT herbicides par parcelle et période")
+                gr.Markdown("""
+                **Calcul de l'IFT (Indice de Fréquence de Traitement) :**
+                - IFT = Nombre d'applications herbicides / Surface de la parcelle
+                - Seuils d'interprétation :
+                  - 🟢 Faible : IFT < 1.0 (pression adventices faible)
+                  - 🟡 Modéré : 1.0 ≤ IFT < 2.0 (pression modérée)
+                  - 🔴 Élevé : IFT ≥ 2.0 (pression élevée)
+                """)
                 
                 with gr.Row():
                     with gr.Column():
@@ -343,6 +483,18 @@ def create_mcp_interface():
                 )
             
             with gr.Tab("🔮 Prédictions"):
+                gr.Markdown("### Prédiction de la pression adventices 2025-2027")
+                gr.Markdown("""
+                **Méthode de prédiction :**
+                1. Calcul de l'IFT historique par parcelle et année
+                2. Régression linéaire : IFT = pente × année + ordonnée_origine
+                3. Extrapolation aux années 2025-2027
+                4. Classification des risques :
+                   - 🟢 Faible : IFT < 1.0
+                   - 🟡 Modéré : 1.0 ≤ IFT < 2.0  
+                   - 🔴 Élevé : IFT ≥ 2.0
+                """)
+                
                 predict_btn = gr.Button("🎯 Prédire 2025-2027", variant="primary")
                 
                 with gr.Row():
@@ -352,6 +504,15 @@ def create_mcp_interface():
                 predict_btn.click(predict_future_weed_pressure, outputs=[predictions_plot, predictions_summary])
             
             with gr.Tab("🌱 Recommandations"):
+                gr.Markdown("### Recommandations pour cultures sensibles (pois, haricot)")
+                gr.Markdown("""
+                **Méthode de recommandation :**
+                1. Prédiction IFT 2025-2027 par régression linéaire
+                2. Filtrage des parcelles à faible risque (IFT < 1.0)
+                3. Calcul du score de recommandation : 100 - (IFT_prédit × 30)
+                4. Classement par score (plus élevé = meilleur)
+                """)
+                
                 recommend_btn = gr.Button("🎯 Recommander Parcelles", variant="primary")
                 
                 with gr.Row():
@@ -360,12 +521,51 @@ def create_mcp_interface():
                 
                 recommend_btn.click(recommend_sensitive_crop_plots, outputs=[recommendations_plot, recommendations_summary])
             
-            with gr.Tab("🔄 Alternatives"):
-                herbicide_type = gr.Dropdown(["Herbicides", "Fongicides"], value="Herbicides", label="Type")
-                alternatives_btn = gr.Button("💡 Générer Alternatives", variant="primary")
-                alternatives_output = gr.Markdown()
+            with gr.Tab("📊 Exploration Données"):
+                gr.Markdown("### Explorer les données brutes de la Station Expérimentale de Kerguéhennec")
+                
+                with gr.Row():
+                    with gr.Column():
+                        data_year_start = gr.Slider(
+                            minimum=2014, 
+                            maximum=2025, 
+                            value=2020, 
+                            step=1, 
+                            label="Année de début"
+                        )
+                        data_year_end = gr.Slider(
+                            minimum=2014, 
+                            maximum=2025, 
+                            value=2025, 
+                            step=1, 
+                            label="Année de fin"
+                        )
+                        data_plot_filter = gr.Dropdown(
+                            choices=get_available_plots(), 
+                            value="Toutes", 
+                            label="Filtrer par parcelle"
+                        )
+                        data_crop_filter = gr.Dropdown(
+                            choices=get_available_crops(), 
+                            value="Toutes", 
+                            label="Filtrer par culture"
+                        )
+                        data_intervention_filter = gr.Dropdown(
+                            choices=get_available_interventions(), 
+                            value="Toutes", 
+                            label="Filtrer par type d'intervention"
+                        )
+                        explore_btn = gr.Button("🔍 Explorer les Données", variant="primary")
+                
+                with gr.Row():
+                    data_plot = gr.Plot()
+                    data_summary = gr.Markdown()
                 
-                alternatives_btn.click(generate_technical_alternatives, [herbicide_type], [alternatives_output])
+                explore_btn.click(
+                    explore_raw_data, 
+                    inputs=[data_year_start, data_year_end, data_plot_filter, data_crop_filter, data_intervention_filter], 
+                    outputs=[data_plot, data_summary]
+                )
     
     return demo
 

test_improved_interface.py

@@ -0,0 +1,44 @@
+"""
+Test de l'interface améliorée
+"""
+
+from mcp_server import analyze_herbicide_trends, predict_future_weed_pressure, recommend_sensitive_crop_plots, explore_raw_data
+
+def test_improved_functions():
+    """Test des fonctions améliorées"""
+    print("🧪 Test de l'interface améliorée...")
+    
+    # Test 1: Analyse tendances
+    print("\nTest 1: Analyse tendances")
+    fig, summary = analyze_herbicide_trends(2020, 2024, "Toutes")
+    if fig is not None:
+        print("✅ Analyse tendances fonctionne")
+    else:
+        print("❌ Erreur:", summary)
+    
+    # Test 2: Prédictions
+    print("\nTest 2: Prédictions")
+    fig, summary = predict_future_weed_pressure()
+    if fig is not None:
+        print("✅ Prédictions fonctionnent")
+    else:
+        print("❌ Erreur:", summary)
+    
+    # Test 3: Recommandations
+    print("\nTest 3: Recommandations")
+    fig, summary = recommend_sensitive_crop_plots()
+    if fig is not None:
+        print("✅ Recommandations fonctionnent")
+    else:
+        print("❌ Erreur:", summary)
+    
+    # Test 4: Exploration données
+    print("\nTest 4: Exploration données")
+    fig, summary = explore_raw_data(2020, 2024, "Toutes", "Toutes", "Toutes")
+    if fig is not None:
+        print("✅ Exploration données fonctionne")
+    else:
+        print("❌ Erreur:", summary)
+
+if __name__ == "__main__":
+    test_improved_functions()