updated

app.py

@@ -1,297 +1,195 @@
 import os
-import json
-import gradio as gr
-from fastapi import FastAPI, Header, HTTPException, Request
-from fastapi.responses import JSONResponse
+from contextlib import asynccontextmanager
+from fastapi import FastAPI
+from fastmcp import FastMCP
 from gradio.routes import mount_gradio_app
 
-# Import your existing Gradio app
+# Import your existing Gradio app and analysis tools
 from gradio_app import create_gradio_app
+from data_loader import AgriculturalDataLoader
+from analysis_tools import AgriculturalAnalyzer
 
 # ========= Configuration =========
 PORT = int(os.environ.get("PORT", 7860))
-MCP_BEARER = os.getenv("MCP_BEARER", "")  # définir dans Spaces > Settings > Variables and secrets
 
-# ========= App FastAPI (parent) =========
-api = FastAPI(title="MCP + Gradio on HF Spaces")
+# Initialize agricultural components
+data_loader = AgriculturalDataLoader()
+analyzer = AgriculturalAnalyzer(data_loader)
 
-@api.get("/health")
-def health():
-    return {"ok": True}
+# ========= Create FastMCP Server =========
+mcp = FastMCP("Agricultural Analysis Tools")
 
-def _check_auth(authorization: str | None):
-    """Vérifie le header Authorization: Bearer <token> si MCP_BEARER est défini."""
-    if not MCP_BEARER:
-        return
-    if not authorization or not authorization.startswith("Bearer "):
-        raise HTTPException(status_code=401, detail="Missing or invalid Authorization header")
-    token = authorization.split(" ", 1)[1]
-    if token != MCP_BEARER:
-        raise HTTPException(status_code=401, detail="Unauthorized")
+@mcp.tool
+def analyze_weed_pressure(years: list[int] | None = None, plots: list[str] | None = None) -> str:
+    """Analyze weed pressure trends using IFT herbicide data from Kerguéhennec experimental station."""
+    try:
+        trends = analyzer.analyze_weed_pressure_trends(years=years, plots=plots)
+        summary_stats = trends['summary']
+        
+        result = f"""🌿 ANALYSE DE LA PRESSION ADVENTICES (IFT Herbicides)
+
+📊 Statistiques pour les années {years or 'toutes'} et parcelles {plots or 'toutes'}:
+• IFT moyen: {summary_stats['mean_ift']:.2f}
+• Écart-type: {summary_stats['std_ift']:.2f}
+• IFT minimum: {summary_stats['min_ift']:.2f}
+• IFT maximum: {summary_stats['max_ift']:.2f}
+• Total applications: {summary_stats['total_applications']}
+• Parcelles analysées: {summary_stats['unique_plots']}
+• Cultures analysées: {summary_stats['unique_crops']}
+
+💡 Interprétation:
+• IFT < 1.0: Pression faible (adapté aux cultures sensibles)
+• IFT 1.0-2.0: Pression modérée
+• IFT > 2.0: Pression élevée"""
+        return result
+    except Exception as e:
+        return f"❌ Erreur lors de l'analyse: {str(e)}"
+
+@mcp.tool
+def predict_future_pressure(target_years: list[int] | None = None, max_ift: float = 1.0) -> str:
+    """Predict future weed pressure and identify suitable plots for sensitive crops."""
+    try:
+        year_list = target_years or [2025, 2026, 2027]
+        predictions = analyzer.predict_weed_pressure(target_years=year_list)
+        model_perf = predictions['model_performance']
+        
+        result = f"""🔮 PRÉDICTION DE LA PRESSION ADVENTICES
+
+🤖 Performance du modèle:
+• R² Score: {model_perf['r2']:.3f}
+• Erreur quadratique moyenne: {model_perf['mse']:.3f}
 
-def handle_mcp_request(payload: dict) -> dict:
-    """Handle MCP JSON-RPC 2.0 requests."""
-    # Validate JSON-RPC 2.0 format
-    if payload.get("jsonrpc") != "2.0":
-        return {
-            "jsonrpc": "2.0",
-            "id": payload.get("id"),
-            "error": {
-                "code": -32600,
-                "message": "Invalid Request",
-                "data": "Missing or invalid jsonrpc version"
-            }
-        }
-    
-    request_id = payload.get("id")
-    method = payload.get("method")
-    params = payload.get("params", {})
-    
-    if not method:
-        return {
-            "jsonrpc": "2.0",
-            "id": request_id,
-            "error": {
-                "code": -32600,
-                "message": "Invalid Request",
-                "data": "Missing method"
-            }
-        }
-    
-    # Handle MCP standard methods
-    if method == "initialize":
-        return {
-            "jsonrpc": "2.0",
-            "id": request_id,
-            "result": {
-                "protocolVersion": "2024-11-05",
-                "capabilities": {
-                    "tools": {
-                        "listChanged": False
-                    },
-                    "resources": {
-                        "subscribe": False,
-                        "listChanged": False
-                    }
-                },
-                "serverInfo": {
-                    "name": "agricultural-mcp-server",
-                    "version": "1.0.0"
-                }
-            }
-        }
-    
-    elif method == "tools/list":
-        return {
-            "jsonrpc": "2.0",
-            "id": request_id,
-            "result": {
-                "tools": [
-                    {
-                        "name": "analyze_weed_pressure",
-                        "description": "Analyze weed pressure trends using IFT herbicide data",
-                        "inputSchema": {
-                            "type": "object",
-                            "properties": {
-                                "years": {
-                                    "type": "array",
-                                    "items": {"type": "integer"},
-                                    "description": "Years to analyze"
-                                },
-                                "plots": {
-                                    "type": "array", 
-                                    "items": {"type": "string"},
-                                    "description": "Plot names to analyze"
-                                }
-                            }
-                        }
-                    },
-                    {
-                        "name": "predict_future_pressure",
-                        "description": "Predict future weed pressure for target years",
-                        "inputSchema": {
-                            "type": "object",
-                            "properties": {
-                                "target_years": {
-                                    "type": "array",
-                                    "items": {"type": "integer"},
-                                    "description": "Years to predict"
-                                },
-                                "max_ift": {
-                                    "type": "number",
-                                    "description": "Maximum IFT threshold for sensitive crops"
-                                }
-                            }
-                        }
-                    },
-                    {
-                        "name": "analyze_crop_rotation",
-                        "description": "Analyze crop rotation impact on weed pressure",
-                        "inputSchema": {
-                            "type": "object",
-                            "properties": {}
-                        }
-                    }
-                ]
-            }
-        }
-    
-    elif method == "tools/call":
-        tool_name = params.get("name")
-        tool_args = params.get("arguments", {})
+📈 Prédictions par année:
+"""
         
-        if tool_name == "analyze_weed_pressure":
-            return {
-                "jsonrpc": "2.0",
-                "id": request_id,
-                "result": {
-                    "content": [
-                        {
-                            "type": "text",
-                            "text": f"Analyse de la pression adventices pour les années {tool_args.get('years', [])} et parcelles {tool_args.get('plots', [])}\n\nCette fonction analyserait normalement les données IFT herbicides de votre dataset agricultural."
-                        }
-                    ]
-                }
-            }
+        for year in year_list:
+            if year in predictions['predictions']:
+                year_pred = predictions['predictions'][year]
+                result += f"\n📅 {year}:\n"
+                for _, row in year_pred.iterrows():
+                    result += f"• {row['plot_name']}: IFT {row['predicted_ift']:.2f} (Risque: {row['risk_level']})\n"
         
-        elif tool_name == "predict_future_pressure":
-            return {
-                "jsonrpc": "2.0",
-                "id": request_id,
-                "result": {
-                    "content": [
-                        {
-                            "type": "text",
-                            "text": f"Prédiction de pression adventices pour {tool_args.get('target_years', [])} avec seuil IFT max {tool_args.get('max_ift', 1.0)}\n\nCette fonction utiliserait vos modèles d'apprentissage automatique pour prédire les futures pressions."
-                        }
-                    ]
-                }
-            }
+        suitable_plots = analyzer.identify_suitable_plots_for_sensitive_crops(
+            target_years=year_list, max_ift_threshold=max_ift
+        )
         
-        elif tool_name == "analyze_crop_rotation":
-            return {
-                "jsonrpc": "2.0",
-                "id": request_id,
-                "result": {
-                    "content": [
-                        {
-                            "type": "text",
-                            "text": "Analyse de l'impact des rotations culturales sur la pression adventices\n\nCette fonction analyserait les patterns de rotation dans votre dataset."
-                        }
-                    ]
-                }
-            }
+        result += f"\n🌱 Parcelles adaptées aux cultures sensibles (IFT < {max_ift}):\n"
+        for year, plots in suitable_plots.items():
+            if plots:
+                result += f"• {year}: {', '.join(plots)}\n"
+            else:
+                result += f"• {year}: Aucune parcelle adaptée\n"
         
-        else:
-            return {
-                "jsonrpc": "2.0",
-                "id": request_id,
-                "error": {
-                    "code": -32601,
-                    "message": "Method not found",
-                    "data": f"Unknown tool: {tool_name}"
-                }
-            }
-    
-    elif method == "resources/list":
-        return {
-            "jsonrpc": "2.0",
-            "id": request_id,
-            "result": {
-                "resources": [
-                    {
-                        "uri": "agricultural://dataset/summary",
-                        "name": "Agricultural Dataset Summary",
-                        "description": "Summary of the Kerguéhennec experimental station dataset",
-                        "mimeType": "text/plain"
-                    }
-                ]
-            }
-        }
-    
-    else:
-        return {
-            "jsonrpc": "2.0",
-            "id": request_id,
-            "error": {
-                "code": -32601,
-                "message": "Method not found",
-                "data": f"Unknown method: {method}"
-            }
-        }
+        return result
+    except Exception as e:
+        return f"❌ Erreur lors de la prédiction: {str(e)}"
 
-# ========= Endpoint MCP (conforme JSON-RPC 2.0) =========
-@api.post("/mcp")
-async def mcp_endpoint(request: Request, authorization: str | None = Header(None)):
-    _check_auth(authorization)
+@mcp.tool
+def analyze_crop_rotation() -> str:
+    """Analyze the impact of crop rotations on weed pressure at Kerguéhennec station."""
     try:
-        payload = await request.json()
-    except Exception:
-        return JSONResponse(
-            status_code=400,
-            content={
-                "jsonrpc": "2.0",
-                "id": None,
-                "error": {
-                    "code": -32700,
-                    "message": "Parse error",
-                    "data": "Invalid JSON"
-                }
-            }
-        )
-    
-    response = handle_mcp_request(payload)
-    return JSONResponse(response)
+        rotation_impact = analyzer.analyze_crop_rotation_impact()
+        
+        if rotation_impact.empty:
+            return "📊 Pas assez de données pour analyser les rotations"
+        
+        result = "🔄 IMPACT DES ROTATIONS CULTURALES\n\n🏆 Meilleures rotations (IFT moyen le plus bas):\n\n"
+        
+        best_rotations = rotation_impact.head(10)
+        for i, (_, row) in enumerate(best_rotations.iterrows(), 1):
+            result += f"{i}. **{row['rotation_type']}**\n"
+            result += f"   • IFT moyen: {row['mean_ift']:.2f}\n"
+            result += f"   • Écart-type: {row['std_ift']:.2f}\n"
+            result += f"   • Observations: {row['count']}\n\n"
+        
+        result += "💡 Les rotations avec les IFT les plus bas sont généralement plus durables."
+        return result
+    except Exception as e:
+        return f"❌ Erreur lors de l'analyse des rotations: {str(e)}"
+
+@mcp.tool
+def get_dataset_summary() -> str:
+    """Get a comprehensive summary of the agricultural dataset from Kerguéhennec experimental station."""
+    try:
+        df = data_loader.load_all_files()
+        if df.empty:
+            return "❌ Aucune donnée disponible"
+        
+        summary = f"""📊 RÉSUMÉ DU DATASET AGRICOLE - STATION DE KERGUÉHENNEC
+
+📈 Statistiques générales:
+• Total d'enregistrements: {len(df):,}
+• Parcelles uniques: {df['plot_name'].nunique()}
+• Types de cultures: {df['crop_type'].nunique()}
+• Années couvertes: {', '.join(map(str, sorted(df['year'].unique())))}
+• Applications herbicides: {len(df[df['is_herbicide'] == True]):,}
+
+🌱 Top 5 des cultures:
+{df['crop_type'].value_counts().head(5).to_string()}
+
+📍 Top 5 des parcelles:
+{df['plot_name'].value_counts().head(5).to_string()}
+
+🏢 Source: Station Expérimentale de Kerguéhennec"""
+        return summary
+    except Exception as e:
+        return f"❌ Erreur lors du chargement des données: {str(e)}"
+
+@mcp.resource("agricultural://dataset/summary")
+def dataset_resource() -> str:
+    """Agricultural dataset summary resource."""
+    return get_dataset_summary()
+
+# ========= Create MCP ASGI app =========
+mcp_app = mcp.http_app(path='/mcp')
+
+# ========= FastAPI App with Lifespan =========
+@asynccontextmanager
+async def lifespan(app: FastAPI):
+    async with mcp_app.lifespan(app):
+        yield
+
+app = FastAPI(
+    title="Agricultural Analysis - MCP + Gradio", 
+    description="Agricultural data analysis with MCP tools and Gradio interface",
+    version="1.0.0",
+    lifespan=lifespan
+)
+
+@app.get("/health")
+def health():
+    """Health check endpoint."""
+    return {"ok": True, "service": "agricultural-mcp-server", "version": "1.0.0"}
 
-# ========= UI Gradio =========
-# Use your existing comprehensive agricultural analysis interface
-demo = create_gradio_app()
+# ========= Mount MCP Server =========
+app.mount("/mcp", mcp_app)
 
-# Monte Gradio sous la racine "/"
-app = mount_gradio_app(api, demo, path="/")
+# ========= Mount Gradio UI =========
+demo = create_gradio_app()
+gradio_app = mount_gradio_app(app, demo, path="/")
 
-# ========= Entrée (pour exécution locale éventuelle) =========
+# ========= Launch Configuration =========
 if __name__ == "__main__":
-    # En local uniquement ; sur Spaces, le runner est géré par la plateforme.
     import uvicorn
-    uvicorn.run(app, host="0.0.0.0", port=PORT)
+    uvicorn.run(gradio_app, host="0.0.0.0", port=PORT)
 
-# ========= Tests curl (exemples conformes JSON-RPC 2.0) =========
-# Healthcheck (public, GET)
+# ========= Tests FastMCP (exemples curl) =========
+# Health check
 # curl -s https://hackathoncra-mcp.hf.space/health
 
-# Test d'initialisation MCP
+# Test MCP tools avec FastMCP
 # curl -s -X POST https://hackathoncra-mcp.hf.space/mcp \
 #   -H "Content-Type: application/json" \
 #   -d '{"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {"protocolVersion": "2024-11-05", "capabilities": {}}}'
 
-# Liste des outils disponibles
 # curl -s -X POST https://hackathoncra-mcp.hf.space/mcp \
 #   -H "Content-Type: application/json" \
 #   -d '{"jsonrpc": "2.0", "id": 2, "method": "tools/list", "params": {}}'
 
-# Appel d'outil - Analyse pression adventices
-# curl -s -X POST https://hackathoncra-mcp.hf.space/mcp \
-#   -H "Content-Type: application/json" \
-#   -d '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "analyze_weed_pressure", "arguments": {"years": [2020, 2021, 2022], "plots": ["P1", "P2"]}}}'
-
-# Appel d'outil - Prédiction future
-# curl -s -X POST https://hackathoncra-mcp.hf.space/mcp \
-#   -H "Content-Type: application/json" \
-#   -d '{"jsonrpc": "2.0", "id": 4, "method": "tools/call", "params": {"name": "predict_future_pressure", "arguments": {"target_years": [2025, 2026], "max_ift": 1.0}}}'
-
-# Appel d'outil - Analyse rotation
-# curl -s -X POST https://hackathoncra-mcp.hf.space/mcp \
-#   -H "Content-Type: application/json" \
-#   -d '{"jsonrpc": "2.0", "id": 5, "method": "tools/call", "params": {"name": "analyze_crop_rotation", "arguments": {}}}'
-
-# Liste des ressources
 # curl -s -X POST https://hackathoncra-mcp.hf.space/mcp \
 #   -H "Content-Type: application/json" \
-#   -d '{"jsonrpc": "2.0", "id": 6, "method": "resources/list", "params": {}}'
+#   -d '{"jsonrpc": "2.0", "id": 3, "method": "tools/call", "params": {"name": "analyze_weed_pressure", "arguments": {"years": [2020, 2021, 2022]}}}'
 
-# Avec authentification Bearer (si MCP_BEARER défini)
 # curl -s -X POST https://hackathoncra-mcp.hf.space/mcp \
-#   -H "Authorization: Bearer VOTRE_TOKEN" \
 #   -H "Content-Type: application/json" \
-#   -d '{"jsonrpc": "2.0", "id": 1, "method": "initialize", "params": {"protocolVersion": "2024-11-05", "capabilities": {}}}'
+#   -d '{"jsonrpc": "2.0", "id": 4, "method": "tools/call", "params": {"name": "get_dataset_summary", "arguments": {}}}'

requirements.txt

@@ -1,6 +1,7 @@
 fastapi>=0.112
 uvicorn[standard]>=0.30
 gradio>=4.43
+fastmcp>=2.11.0
 pandas>=2.0.0
 numpy>=1.24.0
 matplotlib>=3.6.0