updated

agricultural_mcp/__init__.py

@@ -0,0 +1,8 @@
+"""
+Agricultural MCP Module for Weed Pressure Analysis
+"""
+
+from .tools import WeedPressureAnalyzer
+from .resources import AgriculturalResources
+
+__all__ = ['WeedPressureAnalyzer', 'AgriculturalResources']

agricultural_mcp/resources.py

@@ -0,0 +1,96 @@
+import gradio as gr
+from data_loader import AgriculturalDataLoader
+
+
+class AgriculturalResources:
+    def __init__(self):
+        self.data_loader = AgriculturalDataLoader()
+        self.data_cache = None
+
+    def load_data(self):
+        if self.data_cache is None:
+            self.data_cache = self.data_loader.load_all_files()
+        return self.data_cache
+
+    # ===========================
+    # Ressource : Exploitation
+    # ===========================
+    @gr.mcp.resource("exploitation://{siret}")
+    def get_exploitation(self, siret: str) -> dict:
+        """Retourne les infos d'une exploitation à partir du SIRET"""
+        df = self.load_data()
+        exp = df[df["siret"] == siret].iloc[0]
+        return {
+            "siret": exp["siret"],
+            "raison_sociale": exp["raisonsoci"],
+            "pacage": exp["pacage"],
+            "millesime": exp["millesime"],
+        }
+
+    # ===========================
+    # Ressource : Parcelle
+    # ===========================
+    @gr.mcp.resource("parcelle://{numparcell}")
+    def get_parcelle(self, numparcell: str) -> dict:
+        """Retourne les infos d'une parcelle"""
+        df = self.load_data()
+        parc = df[df["numparcell"] == numparcell].iloc[0]
+        return {
+            "numparcell": parc["numparcell"],
+            "nomparc": parc["nomparc"],
+            "surfparc": parc["surfparc"],
+            "numilot": parc["numilot"],
+            "refca": parc["refca"],
+        }
+
+    # ===========================
+    # Ressource : Intervention
+    # ===========================
+    @gr.mcp.resource("intervention://{rang}")
+    def get_intervention(self, rang: str) -> dict:
+        """Retourne les infos d'une intervention"""
+        df = self.load_data()
+        inter = df[df["rang"] == rang].iloc[0]
+        return {
+            "rang": inter["rang"],
+            "date": inter.get("dateinterv", None),
+            "mainoeuvre": inter["mainoeuvre"],
+            "materiel": inter["materiel"],
+        }
+
+    # ===========================
+    # Ressource : Intrants
+    # ===========================
+    @gr.mcp.resource("intrant://{codeamm}")
+    def get_intrant(self, codeamm: str) -> dict:
+        """Retourne les infos d’un produit utilisé"""
+        df = self.load_data()
+        intr = df[df["codeamm"] == codeamm].iloc[0]
+        return {
+            "codeamm": intr["codeamm"],
+            "codegnis": intr["codegnis"],
+            "quantite": intr["kqte"],
+            "teneurN": intr["teneurn"],
+            "teneurP": intr["teneurp"],
+            "teneurK": intr["teneurk"],
+        }
+
+    # ===========================
+    # Ressource : Matériel
+    # ===========================
+    @gr.mcp.resource("materiel://{id}")
+    def get_materiel(self, id: str) -> dict:
+        """Retourne un matériel (ligne correspondante)"""
+        df = self.load_data()
+        mat = df[df.index == int(id)].iloc[0]  # ici on prend par index de ligne
+        return {
+            "materiel": mat["materiel"],
+            "intervention": mat["rang"],
+            "parcelle": mat["numparcell"],
+        }
+
+
+# ===========================
+# Instance pour utilisation
+# ===========================
+resources = AgriculturalResources()

agricultural_mcp/tools.py

@@ -0,0 +1,577 @@
+"""MCP Server for Agricultural Weed Pressure Analysis"""
+
+import gradio as gr
+import pandas as pd
+import numpy as np
+import plotly.express as px
+from data_loader import AgriculturalDataLoader
+import warnings
+warnings.filterwarnings('ignore')
+
+class WeedPressureAnalyzer:
+    """Analyze weed pressure and recommend plots for sensitive crops."""
+    
+    def __init__(self):
+        self.data_loader = AgriculturalDataLoader()
+        self.data_cache = None
+        
+    def load_data(self):
+        if self.data_cache is None:
+            self.data_cache = self.data_loader.load_all_files()
+        return self.data_cache
+    
+    def calculate_herbicide_ift(self, years=None):
+        """Calculate IFT for herbicides by plot and year."""
+        df = self.load_data()
+        
+        if years:
+            df = df[df['year'].isin(years)]
+        
+        herbicide_df = df[df['is_herbicide'] == True].copy()
+        
+        if len(herbicide_df) == 0:
+            return pd.DataFrame()
+        
+        ift_summary = herbicide_df.groupby(['plot_name', 'year', 'crop_type']).agg({
+            'produit': 'count',
+            'plot_surface': 'first',
+            'quantitetot': 'sum'
+        }).reset_index()
+        
+        ift_summary['ift_herbicide'] = ift_summary['produit'] / ift_summary['plot_surface']
+        
+        return ift_summary
+    
+    def predict_weed_pressure(self, target_years=[2025, 2026, 2027]):
+        """Predict weed pressure for future years."""
+        ift_data = self.calculate_herbicide_ift()
+        
+        if len(ift_data) == 0:
+            return pd.DataFrame()
+        
+        predictions = []
+        
+        for plot in ift_data['plot_name'].unique():
+            plot_data = ift_data[ift_data['plot_name'] == plot].sort_values('year')
+            
+            if len(plot_data) < 2:
+                continue
+                
+            years = plot_data['year'].values
+            ift_values = plot_data['ift_herbicide'].values
+            
+            if len(years) > 1:
+                slope = np.polyfit(years, ift_values, 1)[0]
+                intercept = np.polyfit(years, ift_values, 1)[1]
+                
+                for target_year in target_years:
+                    predicted_ift = slope * target_year + intercept
+                    predicted_ift = max(0, predicted_ift)
+                    
+                    if predicted_ift < 1.0:
+                        risk_level = "Faible"
+                    elif predicted_ift < 2.0:
+                        risk_level = "Modéré"
+                    else:
+                        risk_level = "Élevé"
+                    
+                    predictions.append({
+                        'plot_name': plot,
+                        'year': target_year,
+                        'predicted_ift': predicted_ift,
+                        'risk_level': risk_level,
+                        'recent_crops': ', '.join(plot_data['crop_type'].tail(3).unique()),
+                        'historical_avg_ift': plot_data['ift_herbicide'].mean()
+                    })
+        
+        return pd.DataFrame(predictions)
+
+# Initialize analyzer
+analyzer = WeedPressureAnalyzer()
+
+
+
+
+def analyze_herbicide_trends(year_start, year_end, plot_filter):
+    """
+    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)
+        end_year = int(year_end)
+        
+        # S'assurer que start <= end
+        if start_year > end_year:
+            start_year, end_year = end_year, start_year
+            
+        years = list(range(start_year, end_year + 1))
+        
+        ift_data = analyzer.calculate_herbicide_ift(years=years)
+        
+        if len(ift_data) == 0:
+            return None, "Aucune donnée d'herbicides trouvée pour la période sélectionnée."
+        
+        # Filtrage par parcelle si nécessaire
+        if plot_filter and plot_filter != "Toutes":
+            ift_data = ift_data[ift_data['plot_name'] == plot_filter]
+        
+        if len(ift_data) == 0:
+            return None, f"Aucune donnée trouvée pour la parcelle '{plot_filter}' sur la période {years[0]}-{years[-1]}."
+        
+        # Création du graphique
+        fig = px.line(ift_data, 
+                     x='year', 
+                     y='ift_herbicide',
+                     color='plot_name',
+                     title=f'Évolution de l\'IFT Herbicides ({years[0]}-{years[-1]})',
+                     labels={'ift_herbicide': 'IFT Herbicides', 'year': 'Année'},
+                     markers=True)
+        
+        fig.update_layout(
+            height=500,
+            xaxis_title="Année",
+            yaxis_title="IFT Herbicides",
+            legend_title="Parcelle"
+        )
+        
+        # Ajout d'une ligne de référence IFT = 2.0
+        fig.add_hline(y=2.0, line_dash="dash", line_color="red", 
+                     annotation_text="Seuil IFT élevé (2.0)", annotation_position="top right")
+        fig.add_hline(y=1.0, line_dash="dash", line_color="orange", 
+                     annotation_text="Seuil IFT modéré (1.0)", annotation_position="bottom right")
+        
+        # Calcul des statistiques
+        ift_mean = ift_data['ift_herbicide'].mean()
+        ift_max = ift_data['ift_herbicide'].max()
+        ift_min = ift_data['ift_herbicide'].min()
+        n_plots = ift_data['plot_name'].nunique()
+        n_records = len(ift_data)
+        
+        # Classification des niveaux de risque
+        low_risk = len(ift_data[ift_data['ift_herbicide'] < 1.0])
+        moderate_risk = len(ift_data[(ift_data['ift_herbicide'] >= 1.0) & (ift_data['ift_herbicide'] < 2.0)])
+        high_risk = len(ift_data[ift_data['ift_herbicide'] >= 2.0])
+        
+        summary = f"""
+📊 **Analyse de l'IFT Herbicides ({years[0]}-{years[-1]})**
+
+**Période analysée:** {years[0]} à {years[-1]}
+**Parcelle(s):** {plot_filter if plot_filter != "Toutes" else "Toutes les parcelles"}
+
+**Statistiques globales:**
+- IFT moyen: {ift_mean:.2f}
+- IFT minimum: {ift_min:.2f}
+- IFT maximum: {ift_max:.2f}
+- Nombre de parcelles: {n_plots}
+- Nombre d'observations: {n_records}
+
+**Répartition des niveaux de pression:**
+- 🟢 Faible (IFT < 1.0): {low_risk} observations ({low_risk/n_records*100:.1f}%)
+- 🟡 Modérée (1.0 ≤ IFT < 2.0): {moderate_risk} observations ({moderate_risk/n_records*100:.1f}%)
+- 🔴 Élevée (IFT ≥ 2.0): {high_risk} observations ({high_risk/n_records*100:.1f}%)
+
+**Interprétation:**
+- IFT < 1.0: Pression adventices faible ✅
+- 1.0 ≤ IFT < 2.0: Pression adventices modérée ⚠️
+- IFT ≥ 2.0: Pression adventices élevée ❌
+        """
+        
+        return fig, summary
+        
+    except Exception as e:
+        import traceback
+        error_msg = f"Erreur dans l'analyse: {str(e)}\n{traceback.format_exc()}"
+        print(error_msg)
+        return None, error_msg
+
+def predict_future_weed_pressure():
+    """
+    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()
+        
+        if len(predictions) == 0:
+            return None, "Impossible de générer des prédictions."
+        
+        fig = px.bar(predictions, 
+                    x='plot_name', 
+                    y='predicted_ift',
+                    color='risk_level',
+                    facet_col='year',
+                    title='Prédiction Pression Adventices (2025-2027)',
+                    color_discrete_map={'Faible': 'green', 'Modéré': 'orange', 'Élevé': 'red'})
+        
+        low_risk = len(predictions[predictions['risk_level'] == 'Faible'])
+        moderate_risk = len(predictions[predictions['risk_level'] == 'Modéré'])
+        high_risk = len(predictions[predictions['risk_level'] == 'Élevé'])
+        
+        summary = f"""
+🔮 **Prédictions 2025-2027**
+
+**Répartition des risques:**
+- ✅ Risque faible: {low_risk} prédictions
+- ⚠️ Risque modéré: {moderate_risk} prédictions  
+- ❌ Risque élevé: {high_risk} prédictions
+        """
+        
+        return fig, summary
+        
+    except Exception as e:
+        return None, f"Erreur: {str(e)}"
+
+def recommend_sensitive_crop_plots():
+    """
+    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()
+        
+        if len(predictions) == 0:
+            return None, "Aucune recommandation disponible."
+        
+        suitable_plots = predictions[predictions['risk_level'] == "Faible"].copy()
+        
+        if len(suitable_plots) > 0:
+            suitable_plots['recommendation_score'] = 100 - (suitable_plots['predicted_ift'] * 30)
+            suitable_plots = suitable_plots.sort_values('recommendation_score', ascending=False)
+            
+            top_recommendations = suitable_plots.head(10)[['plot_name', 'year', 'predicted_ift', 'recommendation_score']]
+            
+            summary = f"""
+🌱 **Recommandations Cultures Sensibles**
+
+**Top parcelles recommandées:**
+{top_recommendations.to_string(index=False)}
+
+**Critères:** IFT prédit < 1.0 (faible pression adventices)
+            """
+            
+            fig = px.scatter(suitable_plots, 
+                           x='predicted_ift', 
+                           y='recommendation_score',
+                           color='year',
+                           hover_data=['plot_name'],
+                           title='Parcelles Recommandées pour Cultures Sensibles')
+            
+            return fig, summary
+        else:
+            return None, "Aucune parcelle à faible risque identifiée."
+        
+    except Exception as e:
+        return None, f"Erreur: {str(e)}"
+
+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**
+
+**Filtres appliqués:**
+- Période: {year_start}-{year_end}
+- Parcelle: {plot_filter}
+- Culture: {crop_filter}
+- Type d'intervention: {intervention_filter}
+
+**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()}
+
+**Répartition par année:**
+{df['year'].value_counts().sort_index().to_string()}
+
+**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."""
+    try:
+        df = analyzer.load_data()
+        plots = sorted(df['plot_name'].dropna().unique().tolist())
+        return ["Toutes"] + plots
+    except Exception as e:
+        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:
+        gr.Markdown("""
+        # 🚜 Analyse Pression Adventices - CRA Bretagne
+        
+        Anticiper et réduire la pression des adventices pour optimiser les cultures sensibles (pois, haricot).
+        """)
+        
+        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():
+                        with gr.Row():
+                            year_start = gr.Slider(
+                                minimum=2014, 
+                                maximum=2025, 
+                                value=2020, 
+                                step=1, 
+                                label="Année de début"
+                            )
+                            year_end = gr.Slider(
+                                minimum=2014, 
+                                maximum=2025, 
+                                value=2025, 
+                                step=1, 
+                                label="Année de fin"
+                            )
+                        plot_dropdown = gr.Dropdown(
+                            choices=get_available_plots(), 
+                            value="Toutes", 
+                            label="Filtrer par parcelle",
+                            info="Choisissez une parcelle spécifique ou toutes"
+                        )
+                        analyze_btn = gr.Button("🔍 Analyser les Tendances", variant="primary", size="lg")
+                
+                with gr.Row():
+                    with gr.Column(scale=2):
+                        trends_plot = gr.Plot(label="Graphique d'évolution")
+                    with gr.Column(scale=1):
+                        trends_summary = gr.Markdown(label="Résumé statistique")
+                
+                analyze_btn.click(
+                    analyze_herbicide_trends, 
+                    inputs=[year_start, year_end, plot_dropdown], 
+                    outputs=[trends_plot, trends_summary]
+                )
+            
+            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():
+                    predictions_plot = gr.Plot()
+                    predictions_summary = gr.Markdown()
+                
+                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():
+                    recommendations_plot = gr.Plot()
+                    recommendations_summary = gr.Markdown()
+                
+                recommend_btn.click(recommend_sensitive_crop_plots, outputs=[recommendations_plot, recommendations_summary])
+            
+            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()
+                
+                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
+
+
+

app.py

@@ -12,4 +12,4 @@ if hf_token:
 os.environ["DATASET_ID"] = "HackathonCRA/2024"
 
 demo = create_mcp_interface()
-demo.launch(share=True)
+demo.launch(share=True, mcp_server=True)

mcp/__init__.py

@@ -0,0 +1,8 @@
+"""
+MCP Module for Agricultural Weed Pressure Analysis
+"""
+
+from .tools import WeedPressureAnalyzer
+from .resources import AgriculturalResources
+
+__all__ = ['WeedPressureAnalyzer', 'AgriculturalResources']

mcp/resources.py

@@ -0,0 +1,301 @@
+import typing as t
+import pandas as pd
+import gradio as gr
+
+# -------------------------------------------------------------------
+# Hypothèse: AgriculturalDataLoader.load_all_files() concatène 10 CSV
+# et renvoie un DataFrame avec au moins ces colonnes (si présentes):
+# ["millesime","raisonsoci","siret","pacage","refca","numilot","numparcell",
+#  "nomparc","surfparc","rang","kqte","teneurn","teneurp","teneurk",
+#  "keq","volumebo","codeamm","codegnis","materiel","mainoeuvre", ...]
+# -------------------------------------------------------------------
+
+class AgriculturalResources:
+    def __init__(self):
+        self.data_loader = AgriculturalDataLoader()
+        self.data_cache: t.Optional[pd.DataFrame] = None
+
+    def load_data(self) -> pd.DataFrame:
+        if self.data_cache is None:
+            df = self.data_loader.load_all_files()
+
+            # Normalisation minimale & robustesse
+            df = df.copy()
+            # Harmonise noms connus (au cas où)
+            rename_map = {
+                "raisonsoci": "raisonsociale",
+                "numparcelle": "numparcell",
+                "NomParc": "nomparc",
+                "SurfParc": "surfparc",
+            }
+            for k, v in rename_map.items():
+                if k in df.columns and v not in df.columns:
+                    df[v] = df[k]
+
+            # Types & trim
+            for col in ["millesime", "siret", "pacage", "refca", "numilot", "numparcell", "rang",
+                        "codeamm", "codegnis"]:
+                if col in df.columns:
+                    df[col] = df[col].astype(str).str.strip()
+
+            for col in ["nomparc", "raisonsociale", "materiel", "mainoeuvre"]:
+                if col in df.columns:
+                    df[col] = df[col].astype(str).str.strip()
+
+            for col in ["surfparc", "kqte", "teneurn", "teneurp", "teneurk", "keq", "volumebo"]:
+                if col in df.columns:
+                    # coerce = NaN si non convertible
+                    df[col] = pd.to_numeric(df[col], errors="coerce")
+
+            # IDs composites utiles
+            if {"millesime", "numparcell"}.issubset(df.columns):
+                df["parcelle_id"] = df["millesime"] + ":" + df["numparcell"]
+            else:
+                df["parcelle_id"] = None
+
+            if {"millesime", "numparcell", "rang"}.issubset(df.columns):
+                df["intervention_id"] = df["millesime"] + ":" + df["numparcell"] + ":" + df["rang"]
+            else:
+                df["intervention_id"] = None
+
+            self.data_cache = df
+
+        return self.data_cache
+
+    # -------------------------
+    # Utilitaires internes
+    # -------------------------
+    def _safe_first(self, df: pd.DataFrame) -> t.Optional[pd.Series]:
+        if df is None or df.empty:
+            return None
+        return df.iloc[0]
+
+    def _notnull(self, d: dict) -> dict:
+        # Retire les champs None/NaN pour des payloads plus propres
+        return {k: v for k, v in d.items() if pd.notna(v)}
+
+    # -------------------------
+    # LISTINGS / DISCOVERY
+    # -------------------------
+
+    @gr.mcp.resource("dataset://years")
+    def list_years(self) -> t.List[str]:
+        """Liste des millésimes disponibles dans l'ensemble des fichiers."""
+        df = self.load_data()
+        if "millesime" not in df.columns:
+            return []
+        years = sorted(df["millesime"].dropna().astype(str).unique())
+        return years
+
+    @gr.mcp.resource("exploitation://{siret}/parcelles")
+    def list_parcelles_by_exploitation(self, siret: str, millesime: t.Optional[str] = None) -> t.List[dict]:
+        """Liste les parcelles d'une exploitation (optionnellement filtrées par millésime)."""
+        df = self.load_data()
+        q = df[df["siret"] == siret] if "siret" in df.columns else df.iloc[0:0]
+        if millesime:
+            q = q[q["millesime"] == str(millesime)]
+        cols = [c for c in ["parcelle_id","millesime","numparcell","nomparc","surfparc","refca","numilot"] if c in q.columns]
+        out = q[cols].drop_duplicates().to_dict(orient="records")
+        return out
+
+    @gr.mcp.resource("parcelles://search")
+    def search_parcelles(self, query: str = "", millesime: t.Optional[str] = None, limit: int = 50) -> t.List[dict]:
+        """Recherche de parcelles par nom/numéro, filtrable par millésime."""
+        df = self.load_data()
+        q = df
+        if millesime:
+            q = q[q["millesime"] == str(millesime)]
+        if query:
+            mask = False
+            if "numparcell" in q.columns:
+                mask = q["numparcell"].str.contains(query, case=False, na=False)
+            if "nomparc" in q.columns:
+                mask = mask | q["nomparc"].str.contains(query, case=False, na=False)
+            q = q[mask]
+        cols = [c for c in ["parcelle_id","millesime","numparcell","nomparc","surfparc","refca","numilot","siret"] if c in q.columns]
+        return q[cols].drop_duplicates().head(limit).to_dict(orient="records")
+
+    # -------------------------
+    # RESSOURCES CANONIQUES
+    # -------------------------
+
+    @gr.mcp.resource("exploitation://{siret}/{millesime}")
+    def get_exploitation(self, siret: str, millesime: str) -> dict:
+        """Infos d'une exploitation (pour un millésime donné)."""
+        df = self.load_data()
+        q = df[(df["siret"] == siret) & (df["millesime"] == str(millesime))] if {"siret","millesime"}.issubset(df.columns) else df.iloc[0:0]
+        row = self._safe_first(q.sort_values(by=[c for c in ["millesime"] if c in q.columns], ascending=False))
+        if row is None:
+            return {}
+        return self._notnull({
+            "millesime": row.get("millesime"),
+            "siret": row.get("siret"),
+            "raison_sociale": row.get("raisonsociale"),
+            "pacage": row.get("pacage"),
+        })
+
+    @gr.mcp.resource("parcelle://{millesime}/{numparcell}")
+    def get_parcelle(self, millesime: str, numparcell: str) -> dict:
+        """Infos d'une parcelle (identifiée par millésime + numparcell)."""
+        df = self.load_data()
+        q = df[(df["millesime"] == str(millesime)) & (df["numparcell"] == str(numparcell))]
+        row = self._safe_first(q)
+        if row is None:
+            return {}
+        return self._notnull({
+            "parcelle_id": row.get("parcelle_id"),
+            "millesime": row.get("millesime"),
+            "numparcell": row.get("numparcell"),
+            "nomparc": row.get("nomparc"),
+            "surfparc": row.get("surfparc"),
+            "siret": row.get("siret"),
+            "refca": row.get("refca"),
+            "numilot": row.get("numilot"),
+        })
+
+    @gr.mcp.resource("intervention://{millesime}/{numparcell}/{rang}")
+    def get_intervention(self, millesime: str, numparcell: str, rang: str) -> dict:
+        """Infos d'une intervention (clé composite millésime + numparcell + rang)."""
+        df = self.load_data()
+        q = df[(df["millesime"] == str(millesime)) & (df["numparcell"] == str(numparcell)) & (df["rang"] == str(rang))]
+        row = self._safe_first(q)
+        if row is None:
+            return {}
+        return self._notnull({
+            "intervention_id": row.get("intervention_id"),
+            "millesime": row.get("millesime"),
+            "numparcell": row.get("numparcell"),
+            "rang": row.get("rang"),
+            "mainoeuvre": row.get("mainoeuvre"),
+            "materiel": row.get("materiel"),
+            "codeamm": row.get("codeamm"),
+            "codegnis": row.get("codegnis"),
+            "kqte": row.get("kqte"),
+            "teneurn": row.get("teneurn"),
+            "teneurp": row.get("teneurp"),
+            "teneurk": row.get("teneurk"),
+            "keq": row.get("keq"),
+            "volumebo": row.get("volumebo"),
+        })
+
+    @gr.mcp.resource("intrant://{codeamm}")
+    def get_intrant(self, codeamm: str, millesime: t.Optional[str] = None) -> dict:
+        """Infos d’un intrant (filtrable par millésime)."""
+        df = self.load_data()
+        q = df[df["codeamm"] == str(codeamm)] if "codeamm" in df.columns else df.iloc[0:0]
+        if millesime:
+            q = q[q["millesime"] == str(millesime)]
+        row = self._safe_first(q)
+        if row is None:
+            return {}
+        return self._notnull({
+            "codeamm": row.get("codeamm"),
+            "codegnis": row.get("codegnis"),
+            "millesime": row.get("millesime"),
+            "kqte": row.get("kqte"),
+            "teneurn": row.get("teneurn"),
+            "teneurp": row.get("teneurp"),
+            "teneurk": row.get("teneurk"),
+            "keq": row.get("keq"),
+            "volumebo": row.get("volumebo"),
+        })
+
+    @gr.mcp.resource("materiel://{millesime}/{numparcell}/{rang}")
+    def get_materiel(self, millesime: str, numparcell: str, rang: str) -> dict:
+        """Matériel utilisé pour une intervention donnée."""
+        df = self.load_data()
+        q = df[(df["millesime"] == str(millesime)) & (df["numparcell"] == str(numparcell)) & (df["rang"] == str(rang))]
+        row = self._safe_first(q)
+        if row is None:
+            return {}
+        return self._notnull({
+            "millesime": row.get("millesime"),
+            "numparcell": row.get("numparcell"),
+            "rang": row.get("rang"),
+            "materiel": row.get("materiel"),
+        })
+
+    @gr.mcp.resource("maindoeuvre://{millesime}/{numparcell}/{rang}")
+    def get_main_oeuvre(self, millesime: str, numparcell: str, rang: str) -> dict:
+        """Main d’œuvre associée à une intervention donnée."""
+        df = self.load_data()
+        q = df[(df["millesime"] == str(millesime)) & (df["numparcell"] == str(numparcell)) & (df["rang"] == str(rang))]
+        row = self._safe_first(q)
+        if row is None:
+            return {}
+        return self._notnull({
+            "millesime": row.get("millesime"),
+            "numparcell": row.get("numparcell"),
+            "rang": row.get("rang"),
+            "mainoeuvre": row.get("mainoeuvre"),
+        })
+
+# -------------------------------------------------------------------
+# Gradio: interfaces simples de test (onglets)
+# -------------------------------------------------------------------
+
+res = AgriculturalResources()
+
+demo = gr.TabbedInterface(
+    [
+        # Data discovery
+        gr.Interface(res.list_years, inputs=[], outputs=gr.JSON(), title="Years"),
+        gr.Interface(res.list_parcelles_by_exploitation,
+                     inputs=[gr.Textbox(value="18560001000016", label="SIRET"),
+                             gr.Textbox(value="", label="Millesime (optionnel)")],
+                     outputs=gr.JSON(),
+                     title="Parcelles par exploitation"),
+        gr.Interface(res.search_parcelles,
+                     inputs=[gr.Textbox(value="", label="Query (num/nom parcelle)"),
+                             gr.Textbox(value="", label="Millesime (optionnel)"),
+                             gr.Number(value=50, label="Limit")],
+                     outputs=gr.JSON(),
+                     title="Recherche parcelles"),
+
+        # Resources canoniques
+        gr.Interface(res.get_exploitation,
+                     inputs=[gr.Textbox(value="18560001000016", label="SIRET"),
+                             gr.Textbox(value="2025", label="Millesime")],
+                     outputs=gr.JSON(),
+                     title="Exploitation"),
+        gr.Interface(res.get_parcelle,
+                     inputs=[gr.Textbox(value="2025", label="Millesime"),
+                             gr.Textbox(value="12", label="Num parcelle")],
+                     outputs=gr.JSON(),
+                     title="Parcelle"),
+        gr.Interface(res.get_intervention,
+                     inputs=[gr.Textbox(value="2025", label="Millesime"),
+                             gr.Textbox(value="12", label="Num parcelle"),
+                             gr.Textbox(value="1", label="Rang")],
+                     outputs=gr.JSON(),
+                     title="Intervention"),
+        gr.Interface(res.get_intrant,
+                     inputs=[gr.Textbox(value="9100296", label="Code AMM"),
+                             gr.Textbox(value="", label="Millesime (optionnel)")],
+                     outputs=gr.JSON(),
+                     title="Intrant"),
+        gr.Interface(res.get_materiel,
+                     inputs=[gr.Textbox(value="2025", label="Millesime"),
+                             gr.Textbox(value="12", label="Num parcelle"),
+                             gr.Textbox(value="1", label="Rang")],
+                     outputs=gr.JSON(),
+                     title="Matériel"),
+        gr.Interface(res.get_main_oeuvre,
+                     inputs=[gr.Textbox(value="2025", label="Millesime"),
+                             gr.Textbox(value="12", label="Num parcelle"),
+                             gr.Textbox(value="1", label="Rang")],
+                     outputs=gr.JSON(),
+                     title="Main d'œuvre"),
+    ],
+    [
+        "Years",
+        "Parcelles par Exploitation",
+        "Recherche Parcelles",
+        "Exploitation",
+        "Parcelle",
+        "Intervention",
+        "Intrant",
+        "Matériel",
+        "Main d'œuvre",
+    ]
+)

mcp_server.py

@@ -1,538 +1,151 @@
-"""MCP Server for Agricultural Weed Pressure Analysis"""
+"""
+MCP Server for Agricultural Weed Pressure Analysis
+Integrates tools, resources and prompts from the mcp/ folder
+"""
 
 import gradio as gr
 import pandas as pd
 import numpy as np
 import plotly.express as px
 from data_loader import AgriculturalDataLoader
+from agricultural_mcp.tools import WeedPressureAnalyzer, analyze_herbicide_trends, predict_future_weed_pressure, recommend_sensitive_crop_plots, explore_raw_data, get_available_plots, get_available_crops, get_available_interventions
+from agricultural_mcp.resources import AgriculturalResources
 import warnings
 warnings.filterwarnings('ignore')
 
-class WeedPressureAnalyzer:
-    """Analyze weed pressure and recommend plots for sensitive crops."""
-    
-    def __init__(self):
-        self.data_loader = AgriculturalDataLoader()
-        self.data_cache = None
-        
-    def load_data(self):
-        if self.data_cache is None:
-            self.data_cache = self.data_loader.load_all_files()
-        return self.data_cache
-    
-    def calculate_herbicide_ift(self, years=None):
-        """Calculate IFT for herbicides by plot and year."""
-        df = self.load_data()
-        
-        if years:
-            df = df[df['year'].isin(years)]
-        
-        herbicide_df = df[df['is_herbicide'] == True].copy()
-        
-        if len(herbicide_df) == 0:
-            return pd.DataFrame()
-        
-        ift_summary = herbicide_df.groupby(['plot_name', 'year', 'crop_type']).agg({
-            'produit': 'count',
-            'plot_surface': 'first',
-            'quantitetot': 'sum'
-        }).reset_index()
-        
-        ift_summary['ift_herbicide'] = ift_summary['produit'] / ift_summary['plot_surface']
-        
-        return ift_summary
-    
-    def predict_weed_pressure(self, target_years=[2025, 2026, 2027]):
-        """Predict weed pressure for future years."""
-        ift_data = self.calculate_herbicide_ift()
-        
-        if len(ift_data) == 0:
-            return pd.DataFrame()
-        
-        predictions = []
-        
-        for plot in ift_data['plot_name'].unique():
-            plot_data = ift_data[ift_data['plot_name'] == plot].sort_values('year')
-            
-            if len(plot_data) < 2:
-                continue
-                
-            years = plot_data['year'].values
-            ift_values = plot_data['ift_herbicide'].values
-            
-            if len(years) > 1:
-                slope = np.polyfit(years, ift_values, 1)[0]
-                intercept = np.polyfit(years, ift_values, 1)[1]
-                
-                for target_year in target_years:
-                    predicted_ift = slope * target_year + intercept
-                    predicted_ift = max(0, predicted_ift)
-                    
-                    if predicted_ift < 1.0:
-                        risk_level = "Faible"
-                    elif predicted_ift < 2.0:
-                        risk_level = "Modéré"
-                    else:
-                        risk_level = "Élevé"
-                    
-                    predictions.append({
-                        'plot_name': plot,
-                        'year': target_year,
-                        'predicted_ift': predicted_ift,
-                        'risk_level': risk_level,
-                        'recent_crops': ', '.join(plot_data['crop_type'].tail(3).unique()),
-                        'historical_avg_ift': plot_data['ift_herbicide'].mean()
-                    })
-        
-        return pd.DataFrame(predictions)
-
-# Initialize analyzer
+# Initialize analyzer and resources
 analyzer = WeedPressureAnalyzer()
+resources = AgriculturalResources()
 
-
-
-
-def analyze_herbicide_trends(year_start, year_end, plot_filter):
-    """
-    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)
-        end_year = int(year_end)
-        
-        # S'assurer que start <= end
-        if start_year > end_year:
-            start_year, end_year = end_year, start_year
-            
-        years = list(range(start_year, end_year + 1))
-        
-        ift_data = analyzer.calculate_herbicide_ift(years=years)
-        
-        if len(ift_data) == 0:
-            return None, "Aucune donnée d'herbicides trouvée pour la période sélectionnée."
-        
-        # Filtrage par parcelle si nécessaire
-        if plot_filter and plot_filter != "Toutes":
-            ift_data = ift_data[ift_data['plot_name'] == plot_filter]
-        
-        if len(ift_data) == 0:
-            return None, f"Aucune donnée trouvée pour la parcelle '{plot_filter}' sur la période {years[0]}-{years[-1]}."
-        
-        # Création du graphique
-        fig = px.line(ift_data, 
-                     x='year', 
-                     y='ift_herbicide',
-                     color='plot_name',
-                     title=f'Évolution de l\'IFT Herbicides ({years[0]}-{years[-1]})',
-                     labels={'ift_herbicide': 'IFT Herbicides', 'year': 'Année'},
-                     markers=True)
-        
-        fig.update_layout(
-            height=500,
-            xaxis_title="Année",
-            yaxis_title="IFT Herbicides",
-            legend_title="Parcelle"
-        )
-        
-        # Ajout d'une ligne de référence IFT = 2.0
-        fig.add_hline(y=2.0, line_dash="dash", line_color="red", 
-                     annotation_text="Seuil IFT élevé (2.0)", annotation_position="top right")
-        fig.add_hline(y=1.0, line_dash="dash", line_color="orange", 
-                     annotation_text="Seuil IFT modéré (1.0)", annotation_position="bottom right")
-        
-        # Calcul des statistiques
-        ift_mean = ift_data['ift_herbicide'].mean()
-        ift_max = ift_data['ift_herbicide'].max()
-        ift_min = ift_data['ift_herbicide'].min()
-        n_plots = ift_data['plot_name'].nunique()
-        n_records = len(ift_data)
-        
-        # Classification des niveaux de risque
-        low_risk = len(ift_data[ift_data['ift_herbicide'] < 1.0])
-        moderate_risk = len(ift_data[(ift_data['ift_herbicide'] >= 1.0) & (ift_data['ift_herbicide'] < 2.0)])
-        high_risk = len(ift_data[ift_data['ift_herbicide'] >= 2.0])
-        
-        summary = f"""
-📊 **Analyse de l'IFT Herbicides ({years[0]}-{years[-1]})**
-
-**Période analysée:** {years[0]} à {years[-1]}
-**Parcelle(s):** {plot_filter if plot_filter != "Toutes" else "Toutes les parcelles"}
-
-**Statistiques globales:**
-- IFT moyen: {ift_mean:.2f}
-- IFT minimum: {ift_min:.2f}
-- IFT maximum: {ift_max:.2f}
-- Nombre de parcelles: {n_plots}
-- Nombre d'observations: {n_records}
-
-**Répartition des niveaux de pression:**
-- 🟢 Faible (IFT < 1.0): {low_risk} observations ({low_risk/n_records*100:.1f}%)
-- 🟡 Modérée (1.0 ≤ IFT < 2.0): {moderate_risk} observations ({moderate_risk/n_records*100:.1f}%)
-- 🔴 Élevée (IFT ≥ 2.0): {high_risk} observations ({high_risk/n_records*100:.1f}%)
-
-**Interprétation:**
-- IFT < 1.0: Pression adventices faible ✅
-- 1.0 ≤ IFT < 2.0: Pression adventices modérée ⚠️
-- IFT ≥ 2.0: Pression adventices élevée ❌
-        """
-        
-        return fig, summary
-        
-    except Exception as e:
-        import traceback
-        error_msg = f"Erreur dans l'analyse: {str(e)}\n{traceback.format_exc()}"
-        print(error_msg)
-        return None, error_msg
-
-def predict_future_weed_pressure():
-    """
-    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()
-        
-        if len(predictions) == 0:
-            return None, "Impossible de générer des prédictions."
-        
-        fig = px.bar(predictions, 
-                    x='plot_name', 
-                    y='predicted_ift',
-                    color='risk_level',
-                    facet_col='year',
-                    title='Prédiction Pression Adventices (2025-2027)',
-                    color_discrete_map={'Faible': 'green', 'Modéré': 'orange', 'Élevé': 'red'})
-        
-        low_risk = len(predictions[predictions['risk_level'] == 'Faible'])
-        moderate_risk = len(predictions[predictions['risk_level'] == 'Modéré'])
-        high_risk = len(predictions[predictions['risk_level'] == 'Élevé'])
-        
-        summary = f"""
-🔮 **Prédictions 2025-2027**
-
-**Répartition des risques:**
-- ✅ Risque faible: {low_risk} prédictions
-- ⚠️ Risque modéré: {moderate_risk} prédictions  
-- ❌ Risque élevé: {high_risk} prédictions
-        """
-        
-        return fig, summary
-        
-    except Exception as e:
-        return None, f"Erreur: {str(e)}"
-
-def recommend_sensitive_crop_plots():
-    """
-    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
+def create_mcp_interface():
     """
-    try:
-        predictions = analyzer.predict_weed_pressure()
-        
-        if len(predictions) == 0:
-            return None, "Aucune recommandation disponible."
-        
-        suitable_plots = predictions[predictions['risk_level'] == "Faible"].copy()
-        
-        if len(suitable_plots) > 0:
-            suitable_plots['recommendation_score'] = 100 - (suitable_plots['predicted_ift'] * 30)
-            suitable_plots = suitable_plots.sort_values('recommendation_score', ascending=False)
-            
-            top_recommendations = suitable_plots.head(10)[['plot_name', 'year', 'predicted_ift', 'recommendation_score']]
-            
-            summary = f"""
-🌱 **Recommandations Cultures Sensibles**
-
-**Top parcelles recommandées:**
-{top_recommendations.to_string(index=False)}
-
-**Critères:** IFT prédit < 1.0 (faible pression adventices)
-            """
-            
-            fig = px.scatter(suitable_plots, 
-                           x='predicted_ift', 
-                           y='recommendation_score',
-                           color='year',
-                           hover_data=['plot_name'],
-                           title='Parcelles Recommandées pour Cultures Sensibles')
-            
-            return fig, summary
-        else:
-            return None, "Aucune parcelle à faible risque identifiée."
-        
-    except Exception as e:
-        return None, f"Erreur: {str(e)}"
-
-def explore_raw_data(year_start, year_end, plot_filter, crop_filter, intervention_filter):
+    Create the main MCP interface with 5 tabs:
+    1. Analyse Tendances - IFT herbicide analysis
+    2. Prédictions - Weed pressure predictions 2025-2027
+    3. Recommandations - Sensitive crop recommendations
+    4. Exploration Données - Raw data exploration
+    5. MCP Resources - Display resources.py content
     """
-    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**
-
-**Filtres appliqués:**
-- Période: {year_start}-{year_end}
-- Parcelle: {plot_filter}
-- Culture: {crop_filter}
-- Type d'intervention: {intervention_filter}
-
-**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()}
-
-**Répartition par année:**
-{df['year'].value_counts().sort_index().to_string()}
-
-**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."""
-    try:
-        df = analyzer.load_data()
-        plots = sorted(df['plot_name'].dropna().unique().tolist())
-        return ["Toutes"] + plots
-    except Exception as e:
-        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:
+    with gr.Blocks(title="Serveur MCP - Analyse Pression Adventices", theme=gr.themes.Soft()) as demo:
+        gr.Markdown("# 🌾 Serveur MCP - Analyse Pression Adventices")
         gr.Markdown("""
-        # 🚜 Analyse Pression Adventices - CRA Bretagne
+        **Analyse de la pression adventices et recommandations pour cultures sensibles**
         
-        Anticiper et réduire la pression des adventices pour optimiser les cultures sensibles (pois, haricot).
+        Ce serveur MCP (Model Context Protocol) fournit des outils d'analyse pour :
+        - Calculer l'IFT (Indice de Fréquence de Traitement) des herbicides
+        - Prédire la pression adventices pour 2025-2027
+        - Recommander des parcelles pour cultures sensibles (pois, haricot)
+        - Explorer les données agricoles avec filtres avancés
         """)
         
         with gr.Tabs():
+            # Tab 1: Analyse Tendances
             with gr.Tab("📈 Analyse Tendances"):
-                gr.Markdown("### Analyser l'évolution de l'IFT herbicides par parcelle et période")
+                gr.Markdown("### Analyse des tendances IFT herbicides")
                 gr.Markdown("""
-                **Calcul de l'IFT (Indice de Fréquence de Traitement) :**
+                **Méthode de calcul IFT :**
                 - 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)
+                - Analyse de l'évolution temporelle par parcelle
+                - Classification des niveaux de risque : Faible (IFT < 1.0), Modéré (1.0 ≤ IFT < 2.0), Élevé (IFT ≥ 2.0)
                 """)
                 
                 with gr.Row():
                     with gr.Column():
-                        with gr.Row():
-                            year_start = gr.Slider(
-                                minimum=2014, 
-                                maximum=2025, 
-                                value=2020, 
-                                step=1, 
-                                label="Année de début"
-                            )
-                            year_end = gr.Slider(
-                                minimum=2014, 
-                                maximum=2025, 
-                                value=2025, 
-                                step=1, 
-                                label="Année de fin"
-                            )
-                        plot_dropdown = gr.Dropdown(
+                        year_start = gr.Slider(
+                            minimum=2014, 
+                            maximum=2025, 
+                            value=2014, 
+                            step=1, 
+                            label="Année de début"
+                        )
+                        year_end = gr.Slider(
+                            minimum=2014, 
+                            maximum=2025, 
+                            value=2025, 
+                            step=1, 
+                            label="Année de fin"
+                        )
+                        plot_filter = gr.Dropdown(
                             choices=get_available_plots(), 
                             value="Toutes", 
-                            label="Filtrer par parcelle",
-                            info="Choisissez une parcelle spécifique ou toutes"
+                            label="Filtrer par parcelle"
                         )
-                        analyze_btn = gr.Button("🔍 Analyser les Tendances", variant="primary", size="lg")
+                        analyze_btn = gr.Button("📊 Analyser les Tendances", variant="primary")
                 
                 with gr.Row():
-                    with gr.Column(scale=2):
-                        trends_plot = gr.Plot(label="Graphique d'évolution")
-                    with gr.Column(scale=1):
-                        trends_summary = gr.Markdown(label="Résumé statistique")
+                    trend_plot = gr.Plot()
+                    trend_summary = gr.Markdown()
                 
                 analyze_btn.click(
                     analyze_herbicide_trends, 
-                    inputs=[year_start, year_end, plot_dropdown], 
-                    outputs=[trends_plot, trends_summary]
+                    inputs=[year_start, year_end, plot_filter], 
+                    outputs=[trend_plot, trend_summary]
                 )
             
+            # Tab 2: Prédictions
             with gr.Tab("🔮 Prédictions"):
-                gr.Markdown("### Prédiction de la pression adventices 2025-2027")
+                gr.Markdown("### Prédictions de 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
+                - Régression linéaire sur les données IFT historiques
+                - Extrapolation pour les années 2025-2027
+                - Classification des niveaux de risque basée sur l'IFT prédit
+                - Prise en compte de l'historique des cultures récentes
                 """)
                 
-                predict_btn = gr.Button("🎯 Prédire 2025-2027", variant="primary")
+                with gr.Row():
+                    predict_btn = gr.Button("🔮 Générer les Prédictions", variant="primary")
                 
                 with gr.Row():
-                    predictions_plot = gr.Plot()
-                    predictions_summary = gr.Markdown()
+                    pred_plot = gr.Plot()
+                    pred_summary = gr.Markdown()
                 
-                predict_btn.click(predict_future_weed_pressure, outputs=[predictions_plot, predictions_summary])
+                predict_btn.click(
+                    predict_future_weed_pressure, 
+                    outputs=[pred_plot, pred_summary]
+                )
             
+            # Tab 3: Recommandations
             with gr.Tab("🌱 Recommandations"):
-                gr.Markdown("### Recommandations pour cultures sensibles (pois, haricot)")
+                gr.Markdown("### Recommandations pour cultures sensibles")
                 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)
+                **Critères de recommandation :**
+                - Parcelles avec IFT prédit < 1.0 (faible pression adventices)
+                - Score de recommandation : 100 - (IFT_prédit × 30)
+                - Cultures sensibles : pois, haricot
+                - Prise en compte de l'historique cultural récent
                 """)
                 
-                recommend_btn = gr.Button("🎯 Recommander Parcelles", variant="primary")
+                with gr.Row():
+                    recommend_btn = gr.Button("🌱 Générer les Recommandations", variant="primary")
                 
                 with gr.Row():
-                    recommendations_plot = gr.Plot()
-                    recommendations_summary = gr.Markdown()
+                    rec_plot = gr.Plot()
+                    rec_summary = gr.Markdown()
                 
-                recommend_btn.click(recommend_sensitive_crop_plots, outputs=[recommendations_plot, recommendations_summary])
+                recommend_btn.click(
+                    recommend_sensitive_crop_plots, 
+                    outputs=[rec_plot, rec_summary]
+                )
             
-            with gr.Tab("📊 Exploration Données"):
-                gr.Markdown("### Explorer les données brutes de la Station Expérimentale de Kerguéhennec")
+            # Tab 4: Exploration Données
+            with gr.Tab("🔍 Exploration Données"):
+                gr.Markdown("### Exploration des données brutes")
+                gr.Markdown("""
+                **Filtres disponibles :**
+                - Années : 2014-2025
+                - Parcelles : 106 parcelles disponibles
+                - Cultures : 42 types de cultures
+                - Types d'intervention : Herbicides, Fertilisation, Semis, etc.
+                """)
                 
                 with gr.Row():
                     with gr.Column():
                         data_year_start = gr.Slider(
                             minimum=2014, 
                             maximum=2025, 
-                            value=2020, 
+                            value=2014, 
                             step=1, 
                             label="Année de début"
                         )
@@ -570,8 +183,96 @@ def create_mcp_interface():
                     outputs=[data_plot, data_summary]
                 )
             
+            # Tab 5: MCP Resources
+            with gr.Tab("🔧 MCP Resources"):
+                gr.Markdown("### Resources MCP disponibles")
+                gr.Markdown("""
+                **Resources MCP exposées :**
+                - `exploitation://{siret}` - Informations d'exploitation
+                - `parcelle://{numparcell}` - Informations de parcelle
+                - `intervention://{rang}` - Informations d'intervention
+                - `intrant://{codeamm}` - Informations d'intrant
+                - `materiel://{id}` - Informations de matériel
+                """)
+                
+                with gr.Row():
+                    with gr.Column():
+                        gr.Markdown("#### Test des Resources MCP")
+                        
+                        # Test Exploitation
+                        with gr.Row():
+                            siret_input = gr.Textbox(
+                                label="SIRET Exploitation", 
+                                value="18560001000016",
+                                placeholder="18560001000016"
+                            )
+                            siret_btn = gr.Button("🏢 Test Exploitation", variant="secondary")
+                        
+                        # Test Parcelle
+                        with gr.Row():
+                            parcelle_input = gr.Textbox(
+                                label="Numéro Parcelle", 
+                                value="12",
+                                placeholder="12"
+                            )
+                            parcelle_btn = gr.Button("🏞️ Test Parcelle", variant="secondary")
+                        
+                        # Test Intervention
+                        with gr.Row():
+                            intervention_input = gr.Textbox(
+                                label="Rang Intervention", 
+                                value="1",
+                                placeholder="1"
+                            )
+                            intervention_btn = gr.Button("⚙️ Test Intervention", variant="secondary")
+                        
+                        # Test Intrant
+                        with gr.Row():
+                            intrant_input = gr.Textbox(
+                                label="Code AMM Intrant", 
+                                value="9100296",
+                                placeholder="9100296"
+                            )
+                            intrant_btn = gr.Button("🧪 Test Intrant", variant="secondary")
+                        
+                        # Test Matériel
+                        with gr.Row():
+                            materiel_input = gr.Textbox(
+                                label="ID Matériel", 
+                                value="1",
+                                placeholder="1"
+                            )
+                            materiel_btn = gr.Button("🔧 Test Matériel", variant="secondary")
+                    
+                    with gr.Column():
+                        gr.Markdown("#### Résultat")
+                        resource_output = gr.JSON(label="Résultat de la resource")
+                
+                # Connexions des boutons
+                siret_btn.click(
+                    lambda siret: resources.get_exploitation(siret), 
+                    inputs=[siret_input], 
+                    outputs=[resource_output]
+                )
+                parcelle_btn.click(
+                    lambda parcelle: resources.get_parcelle(parcelle), 
+                    inputs=[parcelle_input], 
+                    outputs=[resource_output]
+                )
+                intervention_btn.click(
+                    lambda intervention: resources.get_intervention(intervention), 
+                    inputs=[intervention_input], 
+                    outputs=[resource_output]
+                )
+                intrant_btn.click(
+                    lambda intrant: resources.get_intrant(intrant), 
+                    inputs=[intrant_input], 
+                    outputs=[resource_output]
+                )
+                materiel_btn.click(
+                    lambda materiel: resources.get_materiel(materiel), 
+                    inputs=[materiel_input], 
+                    outputs=[resource_output]
+                )
     
-    return demo
-
-
-
+    return demo

test_new_structure.py

@@ -0,0 +1,47 @@
+"""
+Test de la nouvelle structure avec dossier mcp/
+"""
+
+import os
+from mcp_server import create_mcp_interface
+
+# Hugging Face configuration
+hf_token = os.environ.get("HF_TOKEN")
+if hf_token:
+    os.environ["HF_TOKEN"] = hf_token
+os.environ["DATASET_ID"] = "HackathonCRA/2024"
+
+def test_new_structure():
+    """Test de la nouvelle structure avec dossier mcp/"""
+    print("🧪 Test de la nouvelle structure avec dossier mcp/...")
+    
+    try:
+        demo = create_mcp_interface()
+        print("✅ Interface créée avec succès")
+        
+        # Test des imports
+        from agricultural_mcp.tools import WeedPressureAnalyzer
+        from agricultural_mcp.resources import AgriculturalResources
+        
+        print("✅ Imports des modules mcp/ fonctionnels")
+        
+        # Test des resources
+        resources = AgriculturalResources()
+        print("✅ Resources MCP initialisées")
+        
+        print("\n🎯 Nouvelle structure fonctionnelle !")
+        print("📋 5 onglets disponibles")
+        print("🔧 Onglet MCP Resources avec test des resources")
+        print("📁 Structure modulaire : tools.py, resources.py, prompts.py")
+        print("🚀 Prêt pour déploiement avec mcp_server=True")
+        
+        return True
+        
+    except Exception as e:
+        print(f"❌ Erreur: {e}")
+        import traceback
+        traceback.print_exc()
+        return False
+
+if __name__ == "__main__":
+    test_new_structure()