updated

README_MCP_DEPLOYMENT.md

@@ -0,0 +1,138 @@
+# 🤖 Déploiement MCP HTTP sur Hugging Face Spaces
+
+## Vue d'ensemble
+
+Cette configuration permet d'exposer le serveur MCP via HTTP en plus de l'interface Gradio sur Hugging Face Spaces.
+
+## 🎯 URLs d'accès
+
+Après déploiement sur HF Spaces :
+
+### Interface Gradio
+```
+https://huggingface.co/spaces/[votre-username]/agricultural-analysis
+```
+
+### Serveur MCP HTTP  
+```
+https://[votre-username]-agricultural-analysis.hf.space:8000
+```
+
+## 🔧 Endpoints MCP disponibles
+
+### Informations du serveur
+```http
+GET https://[votre-username]-agricultural-analysis.hf.space:8000/
+```
+
+### Lister les ressources
+```http
+GET https://[votre-username]-agricultural-analysis.hf.space:8000/mcp/resources
+```
+
+### Obtenir une ressource spécifique
+```http
+GET https://[votre-username]-agricultural-analysis.hf.space:8000/mcp/resources/agricultural://data/summary
+```
+
+### Lister les outils
+```http
+GET https://[votre-username]-agricultural-analysis.hf.space:8000/mcp/tools
+```
+
+### Appeler un outil
+```http
+POST https://[votre-username]-agricultural-analysis.hf.space:8000/mcp/call/filter_data
+Content-Type: application/json
+
+{
+  "years": [2022, 2023, 2024],
+  "plots": ["P001", "P002"]
+}
+```
+
+## 🛠️ Configuration MCP Inspector
+
+Pour utiliser avec MCP Inspector :
+
+1. **URL du serveur** : `https://[votre-username]-agricultural-analysis.hf.space:8000`
+2. **Protocole** : HTTP/REST
+3. **Format** : JSON
+
+## 📋 Exemples d'utilisation
+
+### Test de connectivité
+```bash
+curl https://[votre-username]-agricultural-analysis.hf.space:8000/
+```
+
+### Obtenir les outils disponibles
+```bash
+curl https://[votre-username]-agricultural-analysis.hf.space:8000/mcp/tools
+```
+
+### Analyser la pression adventices
+```bash
+curl -X POST https://[votre-username]-agricultural-analysis.hf.space:8000/mcp/call/analyze_weed_pressure \
+  -H "Content-Type: application/json" \
+  -d '{"years": [2022, 2023, 2024], "include_visualization": true}'
+```
+
+### Prédire la pression future
+```bash
+curl -X POST https://[votre-username]-agricultural-analysis.hf.space:8000/mcp/call/predict_weed_pressure \
+  -H "Content-Type: application/json" \
+  -d '{"target_years": [2025, 2026, 2027]}'
+```
+
+### Identifier les parcelles adaptées
+```bash
+curl -X POST https://[votre-username]-agricultural-analysis.hf.space:8000/mcp/call/identify_suitable_plots \
+  -H "Content-Type: application/json" \
+  -d '{"target_years": [2025, 2026, 2027], "max_ift_threshold": 1.0}'
+```
+
+## 🔍 Logs et Debug
+
+Les logs des deux services (Gradio + MCP) apparaîtront dans les logs du Space Hugging Face.
+
+### Vérifier le statut
+- **Gradio** : Interface web accessible
+- **MCP HTTP** : Endpoint `/` répond avec infos du serveur
+
+## ⚙️ Variables d'environnement
+
+```bash
+# Mode de déploiement
+MCP_MODE=http
+
+# Configuration réseau
+MCP_HOST=0.0.0.0
+MCP_PORT=8000
+GRADIO_SERVER_NAME=0.0.0.0
+GRADIO_SERVER_PORT=7860
+
+# Configuration Hugging Face
+HF_TOKEN=your_token_here
+DATASET_ID=HackathonCRA/2024
+```
+
+## 🚀 Déploiement
+
+1. **Push vers HF Spaces** avec les fichiers modifiés
+2. **Attendre le démarrage** (vérifier les logs)
+3. **Tester la connectivité** sur les deux ports
+4. **Configurer MCP Inspector** avec l'URL
+
+## 🔧 Dépannage
+
+### Problème de port
+Si le port 8000 n'est pas accessible, Hugging Face Spaces peut avoir des restrictions. Essayez :
+- Port 8080 ou 3000
+- Modifier `MCP_PORT` dans `app.py`
+
+### Problème de CORS
+Les headers CORS sont configurés pour `allow_origins=["*"]`. Si nécessaire, ajuster dans `mcp_server.py`.
+
+### Timeout de démarrage
+Le MCP server a 2 secondes pour démarrer avant Gradio. Augmentez si nécessaire dans `app.py`.

app.py

@@ -1,36 +1,83 @@
 """
 Hugging Face Space compatible version of the agricultural analysis app.
 This is the main entry point for deployment on Hugging Face Spaces.
+Launches both Gradio interface and MCP HTTP server.
 """
 
 import os
 import sys
 import gradio as gr
+import asyncio
+import threading
+import time
+import logging
 
 # Add current directory to Python path
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
-# Import the main Gradio app
+# Import the main Gradio app and MCP server
 from gradio_app import create_gradio_app
+from mcp_server import main_http
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("hf-space-launcher")
+
+def run_mcp_server():
+    """Run MCP HTTP server in a separate thread."""
+    logger.info("🤖 Starting MCP HTTP Server...")
+    os.environ["MCP_MODE"] = "http"
+    os.environ["MCP_PORT"] = "8000"
+    os.environ["MCP_HOST"] = "0.0.0.0"
+    
+    try:
+        asyncio.run(main_http())
+    except Exception as e:
+        logger.error(f"❌ MCP Server failed: {e}")
+
+def run_gradio_app():
+    """Run Gradio app."""
+    logger.info("🌐 Starting Gradio Interface...")
+    
+    try:
+        app = create_gradio_app()
+        app.launch(
+            server_name="0.0.0.0",
+            server_port=7860,
+            share=False,  # Don't share in HF Spaces
+            debug=False,  # Disable debug in production
+            show_error=True,
+            quiet=False,
+            prevent_thread_lock=True  # Important for threading
+        )
+    except Exception as e:
+        logger.error(f"❌ Gradio failed: {e}")
 
 def main():
-    """Main function for Hugging Face deployment."""
+    """Main function for Hugging Face deployment - runs both services."""
+    logger.info("🚀 Starting Agricultural Analysis Space...")
+    logger.info("📊 Gradio Interface will be on port 7860")
+    logger.info("🤖 MCP HTTP Server will be on port 8000")
+    
     # Set up environment
     os.environ.setdefault("GRADIO_SERVER_NAME", "0.0.0.0")
     os.environ.setdefault("GRADIO_SERVER_PORT", "7860")
     
-    # Create and launch the app
-    app = create_gradio_app()
-    
-    # Launch with Hugging Face compatible settings
-    app.launch(
-        server_name="0.0.0.0",
-        server_port=7860,
-        share=False,  # Don't share in HF Spaces
-        debug=False,  # Disable debug in production
-        show_error=True,
-        quiet=False
-    )
+    try:
+        # Start MCP server in a separate thread
+        mcp_thread = threading.Thread(target=run_mcp_server, daemon=True)
+        mcp_thread.start()
+        logger.info("✅ MCP Server thread started")
+        
+        # Give MCP server time to start
+        time.sleep(2)
+        
+        # Start Gradio app in main thread
+        run_gradio_app()
+        
+    except Exception as e:
+        logger.error(f"❌ Failed to start services: {e}")
+        raise
 
 if __name__ == "__main__":
     main()

mcp_http_server.py

@@ -0,0 +1,22 @@
+"""
+Standalone HTTP MCP Server for Hugging Face Spaces deployment.
+This file launches only the MCP HTTP server on a different port.
+"""
+
+import os
+import asyncio
+import logging
+from mcp_server import main_http
+
+# Set up logging
+logging.basicConfig(level=logging.INFO)
+logger = logging.getLogger("mcp-http-server")
+
+if __name__ == "__main__":
+    # Force HTTP mode
+    os.environ["MCP_MODE"] = "http"
+    os.environ["MCP_PORT"] = "8000" 
+    os.environ["MCP_HOST"] = "0.0.0.0"
+    
+    logger.info("🤖 Starting MCP HTTP Server on port 8000...")
+    asyncio.run(main_http())

mcp_server.py

@@ -15,6 +15,10 @@ import pandas as pd
 from data_loader import AgriculturalDataLoader
 from analysis_tools import AgriculturalAnalyzer
 import plotly.io as pio
+import os
+from fastapi import FastAPI, HTTPException
+from fastapi.middleware.cors import CORSMiddleware
+import uvicorn
 
 
 # Set up logging
@@ -412,9 +416,85 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> List[TextContent]:
         )]
 
 
-async def main():
-    """Main function to run the MCP server."""
-    logger.info("Starting Agricultural MCP Server...")
+# FastAPI app for HTTP interface
+fastapi_app = FastAPI(
+    title="Agricultural MCP Server",
+    description="MCP Server for Agricultural Data Analysis",
+    version="1.0.0"
+)
+
+# Add CORS middleware for web access
+fastapi_app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["*"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+@fastapi_app.get("/")
+async def root():
+    """Root endpoint with server info."""
+    return {
+        "name": "Agricultural MCP Server",
+        "version": "1.0.0",
+        "description": "MCP Server for Agricultural Data Analysis",
+        "endpoints": {
+            "resources": "/mcp/resources",
+            "tools": "/mcp/tools", 
+            "call": "/mcp/call/{tool_name}"
+        }
+    }
+
+@fastapi_app.get("/mcp/resources")
+async def get_resources():
+    """Get available MCP resources."""
+    try:
+        resources = await list_resources()
+        return {"resources": [resource.model_dump() for resource in resources]}
+    except Exception as e:
+        logger.error(f"Error listing resources: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@fastapi_app.get("/mcp/resources/{resource_uri:path}")
+async def get_resource(resource_uri: str):
+    """Get a specific resource."""
+    try:
+        content = await read_resource(resource_uri)
+        return {"uri": resource_uri, "content": content}
+    except Exception as e:
+        logger.error(f"Error reading resource {resource_uri}: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@fastapi_app.get("/mcp/tools")
+async def get_tools():
+    """Get available MCP tools."""
+    try:
+        tools = await list_tools()
+        return {"tools": [tool.model_dump() for tool in tools]}
+    except Exception as e:
+        logger.error(f"Error listing tools: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+@fastapi_app.post("/mcp/call/{tool_name}")
+async def call_mcp_tool(tool_name: str, arguments: Dict[str, Any] = None):
+    """Call an MCP tool."""
+    try:
+        if arguments is None:
+            arguments = {}
+        result = await call_tool(tool_name, arguments)
+        return {
+            "tool": tool_name, 
+            "arguments": arguments,
+            "result": [content.model_dump() for content in result]
+        }
+    except Exception as e:
+        logger.error(f"Error calling tool {tool_name}: {e}")
+        raise HTTPException(status_code=500, detail=str(e))
+
+async def main_stdio():
+    """Main function to run the MCP server via stdio."""
+    logger.info("Starting Agricultural MCP Server (stdio mode)...")
     
     # Initialize the server
     async with stdio_server() as (read_stream, write_stream):
@@ -428,6 +508,31 @@ async def main():
             )
         )
 
+async def main_http():
+    """Main function to run the MCP server via HTTP."""
+    logger.info("Starting Agricultural MCP Server (HTTP mode)...")
+    
+    port = int(os.getenv("MCP_PORT", "8000"))
+    host = os.getenv("MCP_HOST", "0.0.0.0")
+    
+    config = uvicorn.Config(
+        fastapi_app,
+        host=host,
+        port=port,
+        log_level="info",
+        access_log=True
+    )
+    server_instance = uvicorn.Server(config)
+    await server_instance.serve()
+
+def main():
+    """Main entry point - choose mode based on environment."""
+    mode = os.getenv("MCP_MODE", "stdio")
+    
+    if mode == "http":
+        asyncio.run(main_http())
+    else:
+        asyncio.run(main_stdio())
 
 if __name__ == "__main__":
-    asyncio.run(main())
+    main()