updated

.gitattributes

@@ -1,35 +0,0 @@
-*.7z filter=lfs diff=lfs merge=lfs -text
-*.arrow filter=lfs diff=lfs merge=lfs -text
-*.bin filter=lfs diff=lfs merge=lfs -text
-*.bz2 filter=lfs diff=lfs merge=lfs -text
-*.ckpt filter=lfs diff=lfs merge=lfs -text
-*.ftz filter=lfs diff=lfs merge=lfs -text
-*.gz filter=lfs diff=lfs merge=lfs -text
-*.h5 filter=lfs diff=lfs merge=lfs -text
-*.joblib filter=lfs diff=lfs merge=lfs -text
-*.lfs.* filter=lfs diff=lfs merge=lfs -text
-*.mlmodel filter=lfs diff=lfs merge=lfs -text
-*.model filter=lfs diff=lfs merge=lfs -text
-*.msgpack filter=lfs diff=lfs merge=lfs -text
-*.npy filter=lfs diff=lfs merge=lfs -text
-*.npz filter=lfs diff=lfs merge=lfs -text
-*.onnx filter=lfs diff=lfs merge=lfs -text
-*.ot filter=lfs diff=lfs merge=lfs -text
-*.parquet filter=lfs diff=lfs merge=lfs -text
-*.pb filter=lfs diff=lfs merge=lfs -text
-*.pickle filter=lfs diff=lfs merge=lfs -text
-*.pkl filter=lfs diff=lfs merge=lfs -text
-*.pt filter=lfs diff=lfs merge=lfs -text
-*.pth filter=lfs diff=lfs merge=lfs -text
-*.rar filter=lfs diff=lfs merge=lfs -text
-*.safetensors filter=lfs diff=lfs merge=lfs -text
-saved_model/**/* filter=lfs diff=lfs merge=lfs -text
-*.tar.* filter=lfs diff=lfs merge=lfs -text
-*.tar filter=lfs diff=lfs merge=lfs -text
-*.tflite filter=lfs diff=lfs merge=lfs -text
-*.tgz filter=lfs diff=lfs merge=lfs -text
-*.wasm filter=lfs diff=lfs merge=lfs -text
-*.xz filter=lfs diff=lfs merge=lfs -text
-*.zip filter=lfs diff=lfs merge=lfs -text
-*.zst filter=lfs diff=lfs merge=lfs -text
-*tfevents* filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -1,14 +0,0 @@
-__pycache__/
-*.pyc
-*.pyo
-*.pyd
-.Python
-*.so
-.coverage
-.pytest_cache/
-.env
-.venv
-env/
-venv/
-flagged/
-*.log

DEPLOYMENT.md

@@ -1,78 +0,0 @@
-# Déploiement du Serveur MCP Agriculture sur Hugging Face
-
-## Aperçu
-Ce serveur MCP (Model Context Protocol) expose tous les outils d'analyse agricole et de visualisation via une interface Gradio optimisée pour Hugging Face Spaces.
-
-## Architecture
-- **app.py** : Serveur MCP principal avec interface Gradio
-- **data_loader.py** : Chargement des données depuis Hugging Face
-- **herbicide_analyzer.py** : Outils d'analyse des herbicides
-- **config.py** : Configuration centralisée
-
-## Fonctionnalités MCP
-
-### 1. Chargement des données
-- `load_agriculture_data()` : Charge les données depuis le dataset HackathonCRA/2024
-- `get_data_summary()` : Résumé des données chargées
-
-### 2. Analyse des herbicides
-- `analyze_herbicide_usage()` : Analyse statistique des herbicides
-- Types d'analyse : "statistics", "top_parcels", "trends"
-
-### 3. Visualisations
-- `create_herbicide_visualization()` : Graphiques Plotly interactifs
-- Types : "top_ift", "regional_trends"
-
-### 4. Requêtes base de données
-- `query_database()` : Requêtes flexibles sur les données
-- Types : "parcels_by_commune", "products_by_year"
-
-## Déploiement sur Hugging Face
-
-### 1. Créer un Space
-```bash
-git clone https://huggingface.co/spaces/YOUR_USERNAME/agriculture-mcp
-cd agriculture-mcp
-```
-
-### 2. Copier les fichiers
-```bash
-cp -r /path/to/mcp/* .
-```
-
-### 3. Configurer les variables d'environnement
-Dans les settings du Space Hugging Face :
-- `HF_TOKEN` : Token Hugging Face pour accéder au dataset
-
-### 4. Push et déploiement
-```bash
-git add .
-git commit -m "Initial MCP server deployment"
-git push
-```
-
-## Utilisation avec un Agent IA
-
-L'agent IA peut se connecter au serveur MCP et utiliser les outils exposés :
-
-```python
-# Exemple d'utilisation par un agent IA
-agent.connect_mcp_server("https://your-space.hf.space")
-
-# Charger les données
-agent.call_tool("load_agriculture_data")
-
-# Analyser les herbicides
-agent.call_tool("analyze_herbicide_usage", year=2023, analysis_type="statistics")
-
-# Créer une visualisation
-agent.call_tool("create_herbicide_visualization", year=2023, chart_type="top_ift")
-```
-
-## Avantages
-
-1. **Interface unifiée** : Tous les outils dans un seul serveur MCP
-2. **Visualisations interactives** : Graphiques Plotly embarqués
-3. **Déploiement simple** : Prêt pour Hugging Face Spaces
-4. **Extensible** : Facile d'ajouter de nouveaux outils
-5. **Performance** : Optimisé pour les requêtes d'agents IA

GUIDE_UTILISATEUR.md

@@ -1,138 +0,0 @@
-# 🌾 Guide Utilisateur - Serveur MCP Agriculture
-
-## Vue d'ensemble
-
-Le serveur MCP (Model Context Protocol) Agriculture expose tous les outils d'analyse agricole et de visualisation via une interface Gradio. Il permet aux agents IA de se connecter aux données agricoles pour générer des rapports puissants.
-
-## 🚀 Démarrage Rapide
-
-### 1. Installation locale
-```bash
-cd mcp/
-pip install -r requirements.txt
-python app.py
-```
-
-### 2. Interface web
-Ouvrez http://localhost:7860 dans votre navigateur
-
-### 3. Test du serveur
-```bash
-python test_mcp_server.py
-```
-
-## 🛠️ Outils MCP Disponibles
-
-### 📊 Gestion des données
-- **`load_agriculture_data()`** : Charge les données depuis Hugging Face
-- **`get_data_summary()`** : Obtient un résumé des données chargées
-
-### 🌿 Analyse des herbicides
-- **`analyze_herbicide_usage(year, analysis_type)`** : Analyse l'usage d'herbicides
-  - `analysis_type` : "statistics", "top_parcels", "trends"
-
-### 📈 Visualisations
-- **`create_herbicide_visualization(year, chart_type)`** : Crée des graphiques
-  - `chart_type` : "top_ift", "regional_trends"
-
-### 🔍 Requêtes base de données  
-- **`query_database(query_type, **kwargs)`** : Requêtes flexibles
-  - `query_type` : "parcels_by_commune", "products_by_year"
-
-## 🤖 Utilisation par un Agent IA
-
-### Exemple de workflow complet :
-
-```python
-# 1. Connexion au serveur MCP
-agent.connect_mcp_server("https://your-space.hf.space")
-
-# 2. Chargement des données
-result = agent.call_tool("load_agriculture_data")
-
-# 3. Analyse des herbicides
-analysis = agent.call_tool("analyze_herbicide_usage", 
-                          year=2023, 
-                          analysis_type="statistics")
-
-# 4. Création de visualisation
-chart = agent.call_tool("create_herbicide_visualization",
-                       year=2023,
-                       chart_type="top_ift")
-
-# 5. Génération de rapport
-report = agent.generate_report(analysis, chart)
-```
-
-## 📋 Interface Gradio
-
-L'interface web contient 4 onglets :
-
-1. **📊 Chargement des Données** : Charger et résumer les données
-2. **🌿 Analyse des Herbicides** : Analyses spécialisées herbicides  
-3. **📈 Visualisations** : Création de graphiques interactifs
-4. **🔍 Requêtes Base de Données** : Requêtes personnalisées
-
-## 🎯 Cas d'usage
-
-### 1. Analyse de compliance
-```python
-# Identifier les parcelles à risque
-top_parcels = agent.call_tool("analyze_herbicide_usage",
-                             year=2023,
-                             analysis_type="top_parcels")
-```
-
-### 2. Suivi de tendances
-```python
-# Analyser l'évolution par région
-trends = agent.call_tool("analyze_herbicide_usage",
-                        analysis_type="trends")
-```
-
-### 3. Reporting automatisé
-```python
-# Générer des rapports périodiques
-for year in [2021, 2022, 2023]:
-    analysis = agent.call_tool("analyze_herbicide_usage", year=year)
-    chart = agent.call_tool("create_herbicide_visualization", year=year)
-    agent.generate_report(f"Rapport {year}", analysis, chart)
-```
-
-## 🔧 Configuration
-
-### Variables d'environnement
-- `HF_TOKEN` : Token Hugging Face pour accéder aux datasets
-- `GRADIO_ANALYTICS_ENABLED=False` : Désactive les analytics
-
-### Personnalisation
-- **config.py** : Configuration centrale (couleurs, messages, etc.)
-- **requirements.txt** : Dépendances Python
-- **DEPLOYMENT.md** : Guide de déploiement détaillé
-
-## 🌐 Déploiement sur Hugging Face
-
-1. Créer un nouveau Space sur Hugging Face
-2. Copier tous les fichiers du dossier `mcp/`
-3. Configurer la variable `HF_TOKEN` dans les settings
-4. Le déploiement se fait automatiquement
-
-## 🔄 Extensibilité
-
-Pour ajouter de nouveaux outils MCP :
-
-1. Ajouter la méthode dans `AgricultureMCPServer`
-2. Exposer via l'interface Gradio
-3. Documenter dans ce guide
-4. Tester avec `test_mcp_server.py`
-
-## 🆘 Support
-
-- **Tests** : `python test_mcp_server.py`
-- **Exemple** : `python example_agent_usage.py` 
-- **Logs** : Vérifier la console pour les erreurs
-- **Documentation** : Voir DEPLOYMENT.md pour plus de détails
-
----
-
-🎉 **Le serveur MCP Agriculture est prêt à connecter les agents IA aux données agricoles !**

README.md

@@ -1,31 +0,0 @@
----
-title: Agriculture Data MCP Server
-emoji: 🌾
-colorFrom: green
-colorTo: blue
-sdk: gradio
-sdk_version: 5.46.0
-app_file: app.py
-pinned: false
----
-
-# Agriculture Data MCP Server
-
-Ce serveur MCP (Model Context Protocol) expose tous les outils d'analyse agricole et de visualisation de données via une interface Gradio. Il permet aux agents IA de se connecter aux données agricoles et de générer des rapports puissants.
-
-## Fonctionnalités
-
-- **Analyse des herbicides** : Outils spécialisés pour analyser l'utilisation d'herbicides
-- **Visualisations** : Graphiques interactifs avec Plotly
-- **Base de données** : Requêtes sur les données agricoles Hugging Face
-- **Agent IA** : Interface pour connecter des LLM aux données et graphiques
-
-## Utilisation
-
-1. L'interface Gradio expose plusieurs outils MCP
-2. Chaque outil peut être appelé par un agent IA
-3. Les résultats incluent des visualisations et des analyses de données
-
-## Déploiement
-
-Ce serveur est conçu pour être déployé sur Hugging Face Spaces avec le support MCP intégré.

app.py

@@ -1,303 +0,0 @@
-"""
-Serveur MCP pour l'analyse des données agricoles
-Expose les outils d'analyse et de visualisation via Gradio avec support MCP
-"""
-import os
-import json
-import traceback
-import pandas as pd
-import gradio as gr
-import plotly.express as px
-import plotly.graph_objects as go
-from plotly.subplots import make_subplots
-
-# Configuration pour désactiver les analytics Gradio
-os.environ["GRADIO_ANALYTICS_ENABLED"] = "False"
-
-# Import des modules locaux
-from data_loader import DataLoader
-from herbicide_analyzer import HerbicideAnalyzer
-from config import DATASET_ID, HF_TOKEN, PLOT_CONFIG
-
-
-class AgricultureMCPServer:
-    """Serveur MCP pour l'analyse des données agricoles"""
-    
-    def __init__(self):
-        self.data_loader = DataLoader()
-        self.herbicide_analyzer = HerbicideAnalyzer()
-        self.df = None
-        self.is_data_loaded = False
-    
-    def load_agriculture_data(self) -> str:
-        """
-        Charge les données agricoles depuis Hugging Face
-        
-        Returns:
-            str: Message de statut du chargement
-        """
-        try:
-            status = self.data_loader.load_data()
-            self.df = self.data_loader.get_data()
-            
-            if self.df is not None:
-                self.herbicide_analyzer.set_data(self.df)
-                self.is_data_loaded = True
-                return f"✅ Données chargées: {len(self.df)} lignes, {len(self.df.columns)} colonnes"
-            else:
-                self.is_data_loaded = False
-                return f"❌ Échec du chargement: {status}"
-                
-        except Exception as e:
-            self.is_data_loaded = False
-            return f"❌ Erreur lors du chargement: {str(e)}"
-    
-    def get_data_summary(self) -> str:
-        """
-        Obtient un résumé des données chargées
-        
-        Returns:
-            str: JSON avec les statistiques des données
-        """
-        try:
-            if not self.is_data_loaded or self.df is None:
-                return json.dumps({"error": "Aucune donnée chargée. Utilisez load_agriculture_data() d'abord."})
-            
-            summary = {
-                "nombre_lignes": len(self.df),
-                "nombre_colonnes": len(self.df.columns),
-                "colonnes": list(self.df.columns),
-                "annees_disponibles": sorted(self.df['millesime'].unique().tolist()) if 'millesime' in self.df.columns else [],
-                "nombre_parcelles": self.df['numparcell'].nunique() if 'numparcell' in self.df.columns else 0,
-                "familles_produits": self.df['familleprod'].unique().tolist() if 'familleprod' in self.df.columns else []
-            }
-            
-            return json.dumps(summary, indent=2, ensure_ascii=False)
-            
-        except Exception as e:
-            return json.dumps({"error": f"Erreur lors du résumé: {str(e)}"})
-    
-    def analyze_herbicide_usage(self, year: int = 2023, analysis_type: str = "statistics") -> str:
-        """
-        Analyse l'utilisation des herbicides
-        
-        Args:
-            year (int): Année à analyser
-            analysis_type (str): Type d'analyse ("statistics", "top_parcels", "trends")
-            
-        Returns:
-            str: JSON avec les résultats de l'analyse
-        """
-        try:
-            if not self.is_data_loaded:
-                return json.dumps({"error": "Données non chargées. Utilisez load_agriculture_data() d'abord."})
-            
-            if analysis_type == "statistics":
-                stats, msg = self.herbicide_analyzer.get_herbicide_usage_statistics(year)
-                if stats:
-                    return json.dumps({"status": msg, "data": stats}, indent=2, ensure_ascii=False)
-                else:
-                    return json.dumps({"error": msg})
-                    
-            elif analysis_type == "top_parcels":
-                parcels, msg = self.herbicide_analyzer.get_top_ift_parcels_by_year(year, 10)
-                if parcels is not None:
-                    # Convertir DataFrame en dict pour JSON
-                    return json.dumps({
-                        "status": msg, 
-                        "data": parcels.to_dict('records')
-                    }, indent=2, ensure_ascii=False)
-                else:
-                    return json.dumps({"error": msg})
-                    
-            elif analysis_type == "trends":
-                trends, msg = self.herbicide_analyzer.analyze_herbicide_trends_by_region()
-                if trends is not None:
-                    return json.dumps({
-                        "status": msg,
-                        "data": trends.head(20).to_dict('records')  # Limiter pour éviter des réponses trop longues
-                    }, indent=2, ensure_ascii=False)
-                else:
-                    return json.dumps({"error": msg})
-            
-            else:
-                return json.dumps({"error": f"Type d'analyse '{analysis_type}' non supporté"})
-                
-        except Exception as e:
-            return json.dumps({"error": f"Erreur lors de l'analyse: {str(e)}"})
-    
-    def create_herbicide_visualization(self, year: int = 2023, chart_type: str = "top_ift") -> go.Figure:
-        """
-        Crée une visualisation des données herbicides
-        
-        Args:
-            year (int): Année à analyser
-            chart_type (str): Type de graphique ("top_ift", "regional_trends")
-            
-        Returns:
-            plotly.graph_objects.Figure: Graphique Plotly
-        """
-        try:
-            if not self.is_data_loaded:
-                return self._create_error_plot("Données non chargées", "Utilisez load_agriculture_data() d'abord")
-            
-            return self.herbicide_analyzer.create_herbicide_visualization(
-                analysis_type=chart_type,
-                year=year,
-                n_parcels=10
-            )
-            
-        except Exception as e:
-            return self._create_error_plot("Erreur de visualisation", f"Erreur: {str(e)}")
-    
-    def query_database(self, query_type: str, **kwargs) -> str:
-        """
-        Effectue une requête sur la base de données
-        
-        Args:
-            query_type (str): Type de requête
-            **kwargs: Paramètres de la requête
-            
-        Returns:
-            str: JSON avec les résultats
-        """
-        try:
-            if not self.is_data_loaded:
-                return json.dumps({"error": "Données non chargées"})
-            
-            if query_type == "parcels_by_commune":
-                commune = kwargs.get('commune', '')
-                if 'nomcommune' in self.df.columns:
-                    results = self.df[self.df['nomcommune'].str.contains(commune, case=False, na=False)]
-                    return json.dumps({
-                        "count": len(results),
-                        "data": results.head(50).to_dict('records')
-                    }, ensure_ascii=False)
-                else:
-                    return json.dumps({"error": "Colonne 'nomcommune' non disponible"})
-                    
-            elif query_type == "products_by_year":
-                year = kwargs.get('year', 2023)
-                year_data = self.df[self.df['millesime'] == year]
-                products = year_data['familleprod'].value_counts().to_dict() if 'familleprod' in year_data.columns else {}
-                return json.dumps({
-                    "year": year,
-                    "products": products
-                }, ensure_ascii=False)
-            
-            else:
-                return json.dumps({"error": f"Type de requête '{query_type}' non supporté"})
-                
-        except Exception as e:
-            return json.dumps({"error": f"Erreur de requête: {str(e)}"})
-    
-    def _create_error_plot(self, title: str, message: str) -> go.Figure:
-        """Crée un graphique d'erreur"""
-        fig = go.Figure()
-        fig.add_annotation(
-            text=message,
-            xref="paper", yref="paper",
-            x=0.5, y=0.5,
-            showarrow=False,
-            font=dict(size=14, color="red")
-        )
-        fig.update_layout(title=title, width=600, height=400)
-        return fig
-
-
-# Initialisation du serveur MCP
-mcp_server = AgricultureMCPServer()
-
-# Interface Gradio avec support MCP
-with gr.Blocks(title="Agriculture Data MCP Server", theme=gr.themes.Soft()) as demo:
-    gr.Markdown("""
-    # 🌾 Agriculture Data MCP Server
-    
-    Ce serveur MCP expose des outils d'analyse des données agricoles via le Model Context Protocol.
-    Connectez un agent IA pour analyser les données et générer des rapports puissants.
-    """)
-    
-    with gr.Tab("📊 Chargement des Données"):
-        load_btn = gr.Button("Charger les données depuis Hugging Face", variant="primary")
-        load_output = gr.Textbox(label="Statut du chargement", lines=3)
-        
-        summary_btn = gr.Button("Obtenir le résumé des données")
-        summary_output = gr.JSON(label="Résumé des données")
-    
-    with gr.Tab("🌿 Analyse des Herbicides"):
-        with gr.Row():
-            herb_year = gr.Number(value=2023, label="Année", precision=0)
-            herb_analysis = gr.Dropdown(
-                choices=["statistics", "top_parcels", "trends"],
-                value="statistics",
-                label="Type d'analyse"
-            )
-        
-        herb_analyze_btn = gr.Button("Analyser les herbicides")
-        herb_output = gr.JSON(label="Résultats de l'analyse")
-    
-    with gr.Tab("📈 Visualisations"):
-        with gr.Row():
-            viz_year = gr.Number(value=2023, label="Année", precision=0)
-            viz_type = gr.Dropdown(
-                choices=["top_ift", "regional_trends"],
-                value="top_ift",
-                label="Type de graphique"
-            )
-        
-        viz_btn = gr.Button("Créer la visualisation")
-        viz_output = gr.Plot(label="Graphique")
-    
-    with gr.Tab("🔍 Requêtes Base de Données"):
-        with gr.Row():
-            query_type = gr.Dropdown(
-                choices=["parcels_by_commune", "products_by_year"],
-                value="parcels_by_commune",
-                label="Type de requête"
-            )
-            query_param = gr.Textbox(label="Paramètre (commune ou année)", value="")
-        
-        query_btn = gr.Button("Exécuter la requête")
-        query_output = gr.JSON(label="Résultats de la requête")
-    
-    # Connexions des événements
-    load_btn.click(
-        fn=mcp_server.load_agriculture_data,
-        outputs=load_output
-    )
-    
-    summary_btn.click(
-        fn=lambda: json.loads(mcp_server.get_data_summary()),
-        outputs=summary_output
-    )
-    
-    herb_analyze_btn.click(
-        fn=lambda year, analysis: json.loads(mcp_server.analyze_herbicide_usage(int(year), analysis)),
-        inputs=[herb_year, herb_analysis],
-        outputs=herb_output
-    )
-    
-    viz_btn.click(
-        fn=mcp_server.create_herbicide_visualization,
-        inputs=[viz_year, viz_type],
-        outputs=viz_output
-    )
-    
-    query_btn.click(
-        fn=lambda qtype, param: json.loads(mcp_server.query_database(
-            qtype, 
-            commune=param if qtype == "parcels_by_commune" else None,
-            year=int(param) if qtype == "products_by_year" and param.isdigit() else 2023
-        )),
-        inputs=[query_type, query_param],
-        outputs=query_output
-    )
-
-# Lancement du serveur avec support MCP
-if __name__ == "__main__":
-    demo.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=True,
-        mcp_server=True  # Active le support MCP
-    )

config.py

@@ -1,32 +0,0 @@
-"""
-Configuration pour le serveur MCP Agriculture
-"""
-import os
-
-# Configuration Hugging Face
-HF_TOKEN = os.environ.get("HF_TOKEN")
-DATASET_ID = "HackathonCRA/2024"
-
-# Colonnes requises dans le dataset
-REQUIRED_COLUMNS = ["numparcell", "surfparc", "millesime"]
-
-# Configuration des couleurs pour les graphiques
-RISK_COLORS = {
-    'high': '#FF4444',
-    'medium': '#FFA500', 
-    'low': '#44AA44'
-}
-
-# Configuration des graphiques
-PLOT_CONFIG = {
-    "width": 700,
-    "height": 400,
-    "template": "plotly_white"
-}
-
-# Messages constants
-MESSAGES = {
-    "loading": "🔄 Chargement des données depuis Hugging Face...",
-    "no_data": "❌ Impossible de charger les données",
-    "success": "✅ Données chargées avec succès"
-}

data_loader.py

@@ -1,142 +0,0 @@
-"""
-Module de chargement des données depuis Hugging Face pour MCP
-"""
-import os
-import traceback
-import pandas as pd
-from datasets import load_dataset
-from huggingface_hub import HfApi, hf_hub_download
-from config import HF_TOKEN, DATASET_ID, REQUIRED_COLUMNS, MESSAGES
-
-
-class DataLoader:
-    """Classe responsable du chargement des données depuis différentes sources"""
-    
-    def __init__(self):
-        self.df = None
-    
-    def load_data(self):
-        """Charge les données du dataset avec gestion robuste des erreurs."""
-        try:
-            print(MESSAGES["loading"])
-            print(f"📋 Dataset ID: {DATASET_ID}")
-            print(f"📋 Token disponible: {'Oui' if HF_TOKEN else 'Non'}")
-
-            self.df = None
-
-            # Stratégie 1: Chargement direct Hugging Face
-            print("🔄 Stratégie 1: chargement via datasets HF")
-            hf_msg = self._safe_load_from_hf()
-            if self.df is None:
-                if hf_msg:
-                    print(f"❌ Chargement HF échoué: {hf_msg}")
-                
-                # Stratégie 2: Charger directement les fichiers du repo
-                print("🔄 Stratégie 2: chargement via fichiers du dépôt")
-                fallback_msg = self._fallback_load_from_repo_files()
-                if self.df is None:
-                    if fallback_msg:
-                        print(f"❌ Chargement via fichiers échoué: {fallback_msg}")
-                    return MESSAGES["no_data"]
-
-            if self.df is None:
-                return MESSAGES["no_data"]
-
-            print(f"📊 Données chargées: {len(self.df)} lignes")
-            print(f"📊 Colonnes disponibles: {list(self.df.columns)}")
-
-            # Validation des colonnes
-            missing_cols = [col for col in REQUIRED_COLUMNS if col not in self.df.columns]
-            if missing_cols:
-                print(f"❌ Colonnes manquantes: {missing_cols}")
-                self.df = None
-                return f"❌ Colonnes manquantes: {missing_cols}"
-
-            # Nettoyage
-            initial_len = len(self.df)
-            self.df = self.df.dropna(subset=REQUIRED_COLUMNS)
-            print(f"📊 Après nettoyage: {len(self.df)} lignes (était {initial_len})")
-            
-            return MESSAGES["success"]
-
-        except Exception as e:
-            print(f"❌ Erreur générale: {str(e)}")
-            print(f"❌ Traceback: {traceback.format_exc()}")
-            return f"❌ Erreur: {str(e)}"
-
-    def _safe_load_from_hf(self):
-        """Chargement sécurisé depuis Hugging Face"""
-        try:
-            dataset = load_dataset(
-                DATASET_ID,
-                split="train",
-                token=HF_TOKEN,
-                trust_remote_code=True,
-            )
-            print(f"📊 Dataset chargé: {len(dataset)} exemples")
-
-            try:
-                self.df = dataset.to_pandas()
-                print("✅ Conversion to_pandas() réussie")
-                return None
-            except Exception as pandas_error:
-                print(f"❌ Erreur to_pandas(): {pandas_error}")
-                print("🔄 Tentative de conversion manuelle...")
-                data_list = []
-                for i, item in enumerate(dataset):
-                    data_list.append(item)
-                    if i < 5:
-                        print(f"📋 Exemple {i}: {list(item.keys())}")
-                self.df = pd.DataFrame(data_list)
-                print(f"✅ Conversion manuelle réussie: {len(self.df)} lignes")
-                return None
-        except Exception as e:
-            return f"Erreur HF: {str(e)}"
-
-    def _fallback_load_from_repo_files(self):
-        """Fallback pour charger les données en téléchargeant directement les fichiers du repo HF."""
-        try:
-            print("🔄 Tentative de chargement alternatif via fichiers du dépôt...")
-            api = HfApi(token=HF_TOKEN)
-            repo_files = api.list_repo_files(repo_id=DATASET_ID, repo_type="dataset")
-            
-            # Chercher des fichiers de données
-            data_files = [f for f in repo_files if f.endswith(('.csv', '.parquet', '.tsv', '.json'))]
-            print(f"📁 Fichiers de données trouvés: {data_files}")
-            
-            if not data_files:
-                return "Aucun fichier de données trouvé"
-            
-            # Essayer de charger le premier fichier trouvé
-            for file_path in data_files:
-                try:
-                    print(f"📥 Téléchargement de {file_path}...")
-                    local_file = hf_hub_download(
-                        repo_id=DATASET_ID, 
-                        filename=file_path, 
-                        repo_type="dataset",
-                        token=HF_TOKEN
-                    )
-                    
-                    if file_path.endswith('.csv') or file_path.endswith('.tsv'):
-                        sep = '\t' if file_path.endswith('.tsv') else ','
-                        self.df = pd.read_csv(local_file, sep=sep)
-                    elif file_path.endswith('.parquet'):
-                        self.df = pd.read_parquet(local_file)
-                    elif file_path.endswith('.json'):
-                        self.df = pd.read_json(local_file)
-                    
-                    if self.df is not None and len(self.df) > 0:
-                        print(f"✅ Fichier {file_path} chargé avec succès: {len(self.df)} lignes")
-                        return None
-                except Exception as file_error:
-                    print(f"❌ Erreur avec {file_path}: {file_error}")
-                    continue
-            
-            return "Impossible de charger aucun fichier"
-        except Exception as e:
-            return f"Erreur fallback: {str(e)}"
-
-    def get_data(self):
-        """Retourne les données chargées"""
-        return self.df

example_agent_usage.py

@@ -1,151 +0,0 @@
-"""
-Exemple d'utilisation du serveur MCP Agriculture par un agent IA
-"""
-import json
-import requests
-import time
-from typing import Dict, Any
-
-
-class AIAgentMCPClient:
-    """Client MCP pour agent IA"""
-    
-    def __init__(self, server_url: str = "http://localhost:7860"):
-        self.server_url = server_url.rstrip('/')
-        self.session = requests.Session()
-    
-    def call_mcp_tool(self, tool_name: str, **kwargs) -> Dict[str, Any]:
-        """
-        Appelle un outil MCP sur le serveur
-        
-        Args:
-            tool_name (str): Nom de l'outil MCP
-            **kwargs: Paramètres de l'outil
-            
-        Returns:
-            Dict: Résultat de l'outil
-        """
-        try:
-            # Pour ce serveur Gradio, nous simulons l'appel MCP
-            # En production, ceci utiliserait le protocol MCP standard
-            
-            if tool_name == "load_agriculture_data":
-                return {"status": "✅ Données chargées avec succès"}
-            
-            elif tool_name == "get_data_summary":
-                return {
-                    "nombre_lignes": 50000,
-                    "nombre_colonnes": 15,
-                    "annees_disponibles": [2020, 2021, 2022, 2023],
-                    "familles_produits": ["Herbicides", "Fongicides", "Insecticides"]
-                }
-            
-            elif tool_name == "analyze_herbicide_usage":
-                return {
-                    "status": "✅ Analyse terminée",
-                    "data": {
-                        "nombre_parcelles": 12500,
-                        "surface_totale": 45678.9,
-                        "ift_moyen": 2.34,
-                        "nombre_communes": 156
-                    }
-                }
-            
-            else:
-                return {"error": f"Outil '{tool_name}' non trouvé"}
-                
-        except Exception as e:
-            return {"error": f"Erreur d'appel MCP: {str(e)}"}
-
-
-def demonstrate_ai_agent_workflow():
-    """Démontre un workflow typique d'agent IA avec le serveur MCP"""
-    
-    print("🤖 Démonstration d'un Agent IA avec MCP Agriculture")
-    print("=" * 60)
-    
-    # Initialiser le client MCP
-    agent = AIAgentMCPClient()
-    
-    # Scénario: L'agent doit analyser l'utilisation d'herbicides en 2023
-    print("📋 Tâche: Analyser l'utilisation d'herbicides en 2023")
-    print()
-    
-    # Étape 1: Charger les données
-    print("1️⃣ Chargement des données...")
-    result = agent.call_mcp_tool("load_agriculture_data")
-    print(f"   {result.get('status', result)}")
-    print()
-    
-    # Étape 2: Obtenir un aperçu des données
-    print("2️⃣ Obtention du résumé des données...")
-    summary = agent.call_mcp_tool("get_data_summary")
-    if "error" not in summary:
-        print(f"   📊 {summary['nombre_lignes']} lignes de données")
-        print(f"   📅 Années: {summary['annees_disponibles']}")
-        print(f"   🧪 Produits: {', '.join(summary['familles_produits'])}")
-    else:
-        print(f"   ❌ {summary['error']}")
-    print()
-    
-    # Étape 3: Analyser les herbicides
-    print("3️⃣ Analyse des herbicides pour 2023...")
-    analysis = agent.call_mcp_tool("analyze_herbicide_usage", year=2023, analysis_type="statistics")
-    if "error" not in analysis:
-        data = analysis.get('data', {})
-        print(f"   🌿 Parcelles analysées: {data.get('nombre_parcelles', 0):,}")
-        print(f"   📏 Surface totale: {data.get('surface_totale', 0):,.1f} ha")
-        print(f"   📊 IFT moyen: {data.get('ift_moyen', 0):.2f}")
-        print(f"   🏘️ Communes: {data.get('nombre_communes', 0)}")
-    else:
-        print(f"   ❌ {analysis['error']}")
-    print()
-    
-    # Étape 4: Génération du rapport
-    print("4️⃣ Génération du rapport...")
-    report = generate_ai_report(summary, analysis)
-    print(report)
-    print()
-    
-    print("✅ Workflow d'agent IA terminé!")
-
-
-def generate_ai_report(summary: Dict, analysis: Dict) -> str:
-    """Génère un rapport IA basé sur les données analysées"""
-    
-    if "error" in summary or "error" in analysis:
-        return "❌ Impossible de générer le rapport à cause d'erreurs dans les données"
-    
-    data = analysis.get('data', {})
-    
-    report = f"""
-📊 RAPPORT D'ANALYSE - HERBICIDES 2023
-{'='*50}
-
-📈 DONNÉES GÉNÉRALES:
-• Dataset: {summary.get('nombre_lignes', 0):,} lignes de données
-• Couverture: {len(summary.get('annees_disponibles', []))} années
-• Types de produits: {len(summary.get('familles_produits', []))}
-
-🌿 ANALYSE HERBICIDES:
-• Parcelles analysées: {data.get('nombre_parcelles', 0):,}
-• Surface totale: {data.get('surface_totale', 0):,.1f} hectares
-• IFT moyen: {data.get('ift_moyen', 0):.2f}
-• Communes concernées: {data.get('nombre_communes', 0)}
-
-💡 INSIGHTS:
-• L'IFT moyen de {data.get('ift_moyen', 0):.2f} indique {'un usage modéré' if data.get('ift_moyen', 0) < 3 else 'un usage intensif'} d'herbicides
-• La couverture de {data.get('nombre_communes', 0)} communes offre une bonne représentativité territoriale
-• Les données couvrent {data.get('surface_totale', 0):,.0f} ha, soit un échantillon significatif
-
-🎯 RECOMMANDATIONS:
-1. Analyser les parcelles avec IFT élevé pour identifier les pratiques optimisables
-2. Comparer les tendances entre régions pour partager les bonnes pratiques
-3. Suivre l'évolution de l'IFT moyen sur plusieurs années
-"""
-    
-    return report
-
-
-if __name__ == "__main__":
-    demonstrate_ai_agent_workflow()

herbicide_analyzer.py

@@ -1,187 +0,0 @@
-"""
-Module d'analyse avancée des herbicides pour MCP
-"""
-import pandas as pd
-import plotly.express as px
-import plotly.graph_objects as go
-from plotly.subplots import make_subplots
-import numpy as np
-from datetime import datetime, timedelta
-
-
-class HerbicideAnalyzer:
-    """Classe spécialisée dans l'analyse avancée des herbicides"""
-    
-    def __init__(self, data=None):
-        self.df = data
-    
-    def set_data(self, data):
-        """Définit les données à analyser"""
-        self.df = data
-    
-    def get_top_ift_parcels_by_year(self, year, n_parcels=10):
-        """
-        Retourne les N parcelles avec les IFT herbicides les plus élevés pour une année donnée
-        """
-        try:
-            if self.df is None or len(self.df) == 0:
-                return None, "❌ Aucune donnée disponible"
-            
-            # Filtrer par année et herbicides
-            year_data = self.df[
-                (self.df['millesime'] == year) & 
-                (self.df['familleprod'] == 'Herbicides')
-            ].copy()
-            
-            if len(year_data) == 0:
-                return None, f"❌ Aucune donnée d'herbicides pour l'année {year}"
-            
-            # Calculer l'IFT par parcelle
-            if 'quantitetot' not in year_data.columns:
-                return None, "❌ Colonne 'quantitetot' manquante pour le calcul de l'IFT"
-            
-            # Agrégation par parcelle
-            ift_by_parcel = year_data.groupby('numparcell').agg({
-                'quantitetot': 'sum',
-                'surfparc': 'first',
-                'codeinsee': 'first',
-                'nomcommune': 'first' if 'nomcommune' in year_data.columns else 'first'
-            }).reset_index()
-            
-            # Calcul de l'IFT (quantité totale / surface)
-            ift_by_parcel['ift_herbicides'] = ift_by_parcel['quantitetot'] / ift_by_parcel['surfparc']
-            
-            # Top N parcelles
-            top_parcels = ift_by_parcel.nlargest(n_parcels, 'ift_herbicides')
-            
-            return top_parcels, f"✅ Top {len(top_parcels)} parcelles avec IFT herbicides élevé trouvées"
-            
-        except Exception as e:
-            return None, f"❌ Erreur dans l'analyse des IFT: {str(e)}"
-    
-    def analyze_herbicide_trends_by_region(self, years_range=None):
-        """
-        Analyse les tendances d'utilisation d'herbicides par région
-        """
-        try:
-            if self.df is None or len(self.df) == 0:
-                return None, "❌ Aucune donnée disponible"
-            
-            # Filtrer les herbicides
-            herbicide_data = self.df[self.df['familleprod'] == 'Herbicides'].copy()
-            
-            if len(herbicide_data) == 0:
-                return None, "❌ Aucune donnée d'herbicides trouvée"
-            
-            # Filtrer par années si spécifié
-            if years_range:
-                herbicide_data = herbicide_data[
-                    herbicide_data['millesime'].between(years_range[0], years_range[1])
-                ]
-            
-            # Grouper par région et année
-            if 'codeinsee' not in herbicide_data.columns:
-                return None, "❌ Colonne 'codeinsee' manquante"
-            
-            regional_trends = herbicide_data.groupby(['codeinsee', 'millesime']).agg({
-                'quantitetot': 'sum',
-                'surfparc': 'sum',
-                'nomcommune': 'first' if 'nomcommune' in herbicide_data.columns else 'first'
-            }).reset_index()
-            
-            # Calcul de l'IFT régional
-            regional_trends['ift_regional'] = regional_trends['quantitetot'] / regional_trends['surfparc']
-            
-            return regional_trends, f"✅ Analyse des tendances pour {len(regional_trends)} régions/années"
-            
-        except Exception as e:
-            return None, f"❌ Erreur dans l'analyse des tendances: {str(e)}"
-    
-    def get_herbicide_usage_statistics(self, year=None):
-        """
-        Retourne des statistiques détaillées sur l'utilisation d'herbicides
-        """
-        try:
-            if self.df is None or len(self.df) == 0:
-                return None, "❌ Aucune donnée disponible"
-            
-            herbicide_data = self.df[self.df['familleprod'] == 'Herbicides'].copy()
-            
-            if year:
-                herbicide_data = herbicide_data[herbicide_data['millesime'] == year]
-            
-            if len(herbicide_data) == 0:
-                return None, f"❌ Aucune donnée d'herbicides pour l'année {year if year else 'toutes'}"
-            
-            stats = {
-                'nombre_parcelles': herbicide_data['numparcell'].nunique(),
-                'surface_totale': herbicide_data['surfparc'].sum(),
-                'quantite_totale': herbicide_data['quantitetot'].sum(),
-                'ift_moyen': herbicide_data['quantitetot'].sum() / herbicide_data['surfparc'].sum(),
-                'nombre_communes': herbicide_data['codeinsee'].nunique() if 'codeinsee' in herbicide_data.columns else 0,
-                'annees_couvertes': sorted(herbicide_data['millesime'].unique().tolist())
-            }
-            
-            return stats, "✅ Statistiques calculées avec succès"
-            
-        except Exception as e:
-            return None, f"❌ Erreur dans le calcul des statistiques: {str(e)}"
-    
-    def create_herbicide_visualization(self, analysis_type="trends", **kwargs):
-        """
-        Crée des visualisations pour l'analyse des herbicides
-        """
-        try:
-            if analysis_type == "top_ift":
-                year = kwargs.get('year', 2023)
-                n_parcels = kwargs.get('n_parcels', 10)
-                data, msg = self.get_top_ift_parcels_by_year(year, n_parcels)
-                
-                if data is None:
-                    return self._create_error_plot("Erreur Top IFT", msg)
-                
-                fig = px.bar(
-                    data, 
-                    x='numparcell', 
-                    y='ift_herbicides',
-                    title=f'Top {n_parcels} Parcelles - IFT Herbicides {year}',
-                    labels={'ift_herbicides': 'IFT Herbicides', 'numparcell': 'Numéro Parcelle'}
-                )
-                
-            elif analysis_type == "regional_trends":
-                years_range = kwargs.get('years_range', None)
-                data, msg = self.analyze_herbicide_trends_by_region(years_range)
-                
-                if data is None:
-                    return self._create_error_plot("Erreur Tendances Régionales", msg)
-                
-                fig = px.line(
-                    data,
-                    x='millesime',
-                    y='ift_regional', 
-                    color='codeinsee',
-                    title='Tendances IFT Herbicides par Région',
-                    labels={'ift_regional': 'IFT Régional', 'millesime': 'Année'}
-                )
-                
-            else:
-                return self._create_error_plot("Type d'analyse non supporté", f"Type '{analysis_type}' non reconnu")
-            
-            fig.update_layout(width=800, height=500)
-            return fig
-            
-        except Exception as e:
-            return self._create_error_plot("Erreur de visualisation", f"Erreur: {str(e)}")
-    
-    def _create_error_plot(self, title, message):
-        """Crée un graphique d'erreur"""
-        fig = go.Figure()
-        fig.add_annotation(
-            text=message,
-            xref="paper", yref="paper",
-            x=0.5, y=0.5,
-            showarrow=False,
-            font=dict(size=14, color="red")
-        )
-        fig.update_layout(title=title, width=600, height=400)
-        return fig

requirements.txt

@@ -1,11 +0,0 @@
-gradio[mcp]>=5.46.0
-pandas>=2.0.0
-numpy>=1.24.0
-plotly>=5.17.0
-seaborn>=0.12.0
-matplotlib>=3.7.0
-datasets>=2.14.0
-huggingface_hub>=0.17.0
-pyarrow>=12.0.0
-scikit-learn>=1.3.0
-textblob>=0.17.1

run_server.sh

@@ -1,30 +0,0 @@
-#!/bin/bash
-
-# Script de lancement du serveur MCP Agriculture
-echo "🌾 Lancement du serveur MCP Agriculture"
-echo "======================================"
-
-# Vérifier si Python est disponible
-if ! command -v python3 &> /dev/null; then
-    echo "❌ Python3 n'est pas installé"
-    exit 1
-fi
-
-# Installer les dépendances si nécessaire
-if [ ! -d "venv" ]; then
-    echo "📦 Création de l'environnement virtuel..."
-    python3 -m venv venv
-    source venv/bin/activate
-    pip install -r requirements.txt
-else
-    echo "📦 Activation de l'environnement virtuel..."
-    source venv/bin/activate
-fi
-
-# Tester le serveur
-echo "🧪 Test du serveur..."
-python test_mcp_server.py
-
-# Lancer le serveur Gradio
-echo "🚀 Lancement du serveur MCP sur http://localhost:7860"
-python app.py

test_mcp_server.py

@@ -1,94 +0,0 @@
-"""
-Script de test pour le serveur MCP Agriculture
-"""
-import json
-import sys
-import os
-
-# Ajouter le répertoire courant au path pour les imports
-sys.path.append(os.path.dirname(os.path.abspath(__file__)))
-
-from app import AgricultureMCPServer
-
-
-def test_mcp_server():
-    """Test du serveur MCP"""
-    print("🧪 Test du serveur MCP Agriculture")
-    print("=" * 50)
-    
-    # Initialiser le serveur
-    server = AgricultureMCPServer()
-    
-    # Test 1: Chargement des données
-    print("📊 Test 1: Chargement des données")
-    result = server.load_agriculture_data()
-    print(f"Résultat: {result}")
-    print()
-    
-    # Test 2: Résumé des données
-    print("📋 Test 2: Résumé des données")
-    summary = server.get_data_summary()
-    try:
-        summary_data = json.loads(summary)
-        if "error" in summary_data:
-            print(f"❌ Erreur: {summary_data['error']}")
-        else:
-            print(f"✅ Données disponibles: {summary_data.get('nombre_lignes', 0)} lignes")
-            print(f"   Colonnes: {len(summary_data.get('colonnes', []))}")
-            print(f"   Années: {summary_data.get('annees_disponibles', [])}")
-    except json.JSONDecodeError:
-        print(f"❌ Erreur de parsing JSON: {summary}")
-    print()
-    
-    # Test 3: Analyse des herbicides
-    print("🌿 Test 3: Analyse des herbicides")
-    herb_result = server.analyze_herbicide_usage(2023, "statistics")
-    try:
-        herb_data = json.loads(herb_result)
-        if "error" in herb_data:
-            print(f"❌ Erreur: {herb_data['error']}")
-        else:
-            print(f"✅ Analyse réussie: {herb_data.get('status', 'OK')}")
-            if "data" in herb_data:
-                data = herb_data["data"]
-                print(f"   Parcelles: {data.get('nombre_parcelles', 0)}")
-                print(f"   Surface totale: {data.get('surface_totale', 0):.2f}")
-    except json.JSONDecodeError:
-        print(f"❌ Erreur de parsing JSON: {herb_result}")
-    print()
-    
-    # Test 4: Visualisation
-    print("📈 Test 4: Création de visualisation")
-    try:
-        fig = server.create_herbicide_visualization(2023, "top_ift")
-        if fig and hasattr(fig, 'data'):
-            print("✅ Visualisation créée avec succès")
-            print(f"   Type: {type(fig).__name__}")
-        else:
-            print("❌ Échec de création de la visualisation")
-    except Exception as e:
-        print(f"❌ Erreur lors de la visualisation: {str(e)}")
-    print()
-    
-    # Test 5: Requête base de données
-    print("🔍 Test 5: Requête base de données")
-    query_result = server.query_database("products_by_year", year=2023)
-    try:
-        query_data = json.loads(query_result)
-        if "error" in query_data:
-            print(f"❌ Erreur: {query_data['error']}")
-        else:
-            print(f"✅ Requête réussie pour l'année {query_data.get('year', 2023)}")
-            products = query_data.get('products', {})
-            print(f"   Produits trouvés: {len(products)}")
-            for prod, count in list(products.items())[:3]:  # Afficher les 3 premiers
-                print(f"   - {prod}: {count}")
-    except json.JSONDecodeError:
-        print(f"❌ Erreur de parsing JSON: {query_result}")
-    print()
-    
-    print("🎉 Tests terminés!")
-
-
-if __name__ == "__main__":
-    test_mcp_server()