updated

PROMPT.md

@@ -37,7 +37,7 @@ hf_token = os.environ.get("HF_TOKEN")
 dataset_id = "HackathonCRA/2024"
 
 
-(dataset accessible via HF avec cet id et ce token, synchronisé depuis OneDrive_1_9-17-2025).
+(dataset accessible via HF avec cet id et ce token, ces données sont dispo pour toi dans OneDrive_1_9-17-2025. Ce dossier sert uniquement a t'aider mais tu dois utiliser data_loader.py pour charger ces données qui sont sur HF en format csv).
 
 Fournir au LLM des tools et resources pour :
 

agricultural_mcp/resources.py

@@ -1,96 +1,237 @@
+import typing as t
+import pandas as pd
 import gradio as gr
 from data_loader import AgriculturalDataLoader
 
+# -------------------------------------------------------------------
+# 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 = None
+        self.data_cache: t.Optional[pd.DataFrame] = None
 
-    def load_data(self):
+    def load_data(self) -> pd.DataFrame:
         if self.data_cache is None:
-            self.data_cache = self.data_loader.load_all_files()
+            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
 
-    # ===========================
-    # Ressource : Exploitation
-    # ===========================
-    @gr.mcp.resource("exploitation://{siret}")
-    def get_exploitation(self, siret: str) -> dict:
-        """Retourne les infos d'une exploitation à partir du SIRET"""
+    # -------------------------
+    # 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()
-        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"""
+        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()
-        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"""
+        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()
-        inter = df[df["rang"] == rang].iloc[0]
-        return {
-            "rang": inter["rang"],
-            "date": inter.get("dateinterv", None),
-            "mainoeuvre": inter["mainoeuvre"],
-            "materiel": inter["materiel"],
-        }
-
-    # ===========================
-    # Ressource : Intrants
-    # ===========================
+        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) -> dict:
-        """Retourne les infos d’un produit utilisé"""
+    def get_intrant(self, codeamm: str, millesime: t.Optional[str] = None) -> dict:
+        """Infos d’un intrant (filtrable par millésime)."""
         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)"""
+        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()
-        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"],
-        }
+        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"),
+        })
 
-# ===========================
+# -------------------------------------------------------------------
 # Instance pour utilisation
-# ===========================
+# -------------------------------------------------------------------
 resources = AgriculturalResources()

mcp_server.py

@@ -188,17 +188,22 @@ def create_mcp_interface():
                 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
+                - `dataset://years` - Liste des millésimes disponibles
+                - `exploitation://{siret}/{millesime}` - Informations d'exploitation
+                - `parcelle://{millesime}/{numparcell}` - Informations de parcelle
+                - `intervention://{millesime}/{numparcell}/{rang}` - Informations d'intervention
                 - `intrant://{codeamm}` - Informations d'intrant
-                - `materiel://{id}` - Informations de matériel
+                - `materiel://{millesime}/{numparcell}/{rang}` - Informations de matériel
+                - `maindoeuvre://{millesime}/{numparcell}/{rang}` - Informations de main d'œuvre
                 """)
                 
                 with gr.Row():
                     with gr.Column():
                         gr.Markdown("#### Test des Resources MCP")
                         
+                        # Test Years
+                        years_btn = gr.Button("📅 Liste des Années", variant="primary")
+                        
                         # Test Exploitation
                         with gr.Row():
                             siret_input = gr.Textbox(
@@ -206,10 +211,20 @@ def create_mcp_interface():
                                 value="18560001000016",
                                 placeholder="18560001000016"
                             )
+                            siret_millesime_input = gr.Textbox(
+                                label="Millesime", 
+                                value="2025",
+                                placeholder="2025"
+                            )
                             siret_btn = gr.Button("🏢 Test Exploitation", variant="secondary")
                         
                         # Test Parcelle
                         with gr.Row():
+                            parcelle_millesime_input = gr.Textbox(
+                                label="Millesime", 
+                                value="2025",
+                                placeholder="2025"
+                            )
                             parcelle_input = gr.Textbox(
                                 label="Numéro Parcelle", 
                                 value="12",
@@ -219,8 +234,18 @@ def create_mcp_interface():
                         
                         # Test Intervention
                         with gr.Row():
-                            intervention_input = gr.Textbox(
-                                label="Rang Intervention", 
+                            intervention_millesime_input = gr.Textbox(
+                                label="Millesime", 
+                                value="2025",
+                                placeholder="2025"
+                            )
+                            intervention_parcelle_input = gr.Textbox(
+                                label="Num Parcelle", 
+                                value="12",
+                                placeholder="12"
+                            )
+                            intervention_rang_input = gr.Textbox(
+                                label="Rang", 
                                 value="1",
                                 placeholder="1"
                             )
@@ -233,12 +258,27 @@ def create_mcp_interface():
                                 value="9100296",
                                 placeholder="9100296"
                             )
+                            intrant_millesime_input = gr.Textbox(
+                                label="Millesime (optionnel)", 
+                                value="",
+                                placeholder="2025"
+                            )
                             intrant_btn = gr.Button("🧪 Test Intrant", variant="secondary")
                         
                         # Test Matériel
                         with gr.Row():
-                            materiel_input = gr.Textbox(
-                                label="ID Matériel", 
+                            materiel_millesime_input = gr.Textbox(
+                                label="Millesime", 
+                                value="2025",
+                                placeholder="2025"
+                            )
+                            materiel_parcelle_input = gr.Textbox(
+                                label="Num Parcelle", 
+                                value="12",
+                                placeholder="12"
+                            )
+                            materiel_rang_input = gr.Textbox(
+                                label="Rang", 
                                 value="1",
                                 placeholder="1"
                             )
@@ -249,29 +289,33 @@ def create_mcp_interface():
                         resource_output = gr.JSON(label="Résultat de la resource")
                 
                 # Connexions des boutons
+                years_btn.click(
+                    lambda: resources.list_years(), 
+                    outputs=[resource_output]
+                )
                 siret_btn.click(
-                    lambda siret: resources.get_exploitation(siret), 
-                    inputs=[siret_input], 
+                    lambda siret, millesime: resources.get_exploitation(siret, millesime), 
+                    inputs=[siret_input, siret_millesime_input], 
                     outputs=[resource_output]
                 )
                 parcelle_btn.click(
-                    lambda parcelle: resources.get_parcelle(parcelle), 
-                    inputs=[parcelle_input], 
+                    lambda millesime, parcelle: resources.get_parcelle(millesime, parcelle), 
+                    inputs=[parcelle_millesime_input, parcelle_input], 
                     outputs=[resource_output]
                 )
                 intervention_btn.click(
-                    lambda intervention: resources.get_intervention(intervention), 
-                    inputs=[intervention_input], 
+                    lambda millesime, parcelle, rang: resources.get_intervention(millesime, parcelle, rang), 
+                    inputs=[intervention_millesime_input, intervention_parcelle_input, intervention_rang_input], 
                     outputs=[resource_output]
                 )
                 intrant_btn.click(
-                    lambda intrant: resources.get_intrant(intrant), 
-                    inputs=[intrant_input], 
+                    lambda codeamm, millesime: resources.get_intrant(codeamm, millesime if millesime else None), 
+                    inputs=[intrant_input, intrant_millesime_input], 
                     outputs=[resource_output]
                 )
                 materiel_btn.click(
-                    lambda materiel: resources.get_materiel(materiel), 
-                    inputs=[materiel_input], 
+                    lambda millesime, parcelle, rang: resources.get_materiel(millesime, parcelle, rang), 
+                    inputs=[materiel_millesime_input, materiel_parcelle_input, materiel_rang_input], 
                     outputs=[resource_output]
                 )
     

test_fixed_resources.py

@@ -0,0 +1,47 @@
+"""
+Test de l'application avec resources corrigées
+"""
+
+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_fixed_resources():
+    """Test de l'application avec resources corrigées"""
+    print("🧪 Test de l'application avec resources corrigées...")
+    
+    try:
+        demo = create_mcp_interface()
+        print("✅ Interface créée avec succès")
+        
+        # Test des resources
+        from agricultural_mcp.resources import AgriculturalResources
+        resources = AgriculturalResources()
+        
+        print("✅ Resources MCP initialisées")
+        
+        # Test d'une resource simple
+        years = resources.list_years()
+        print(f"✅ Test list_years: {len(years)} années trouvées")
+        
+        print("\n🎯 Application avec resources corrigées fonctionnelle !")
+        print("📋 5 onglets disponibles")
+        print("🔧 Onglet MCP Resources avec test des resources corrigées")
+        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_fixed_resources()