updated

README_MCP_DEPLOYMENT.md

@@ -1,138 +0,0 @@
-# 🤖 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,83 +1,36 @@
 """
 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 and MCP server
+# Import the main Gradio app
 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 - 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")
-    
+    """Main function for Hugging Face deployment."""
     # Set up environment
     os.environ.setdefault("GRADIO_SERVER_NAME", "0.0.0.0")
     os.environ.setdefault("GRADIO_SERVER_PORT", "7860")
     
-    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
+    # 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
+    )
 
 if __name__ == "__main__":
     main()

mcp_http_server.py

@@ -1,22 +0,0 @@
-"""
-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,10 +15,6 @@ 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
@@ -416,85 +412,9 @@ async def call_tool(name: str, arguments: Dict[str, Any]) -> List[TextContent]:
         )]
 
 
-# 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)...")
+async def main():
+    """Main function to run the MCP server."""
+    logger.info("Starting Agricultural MCP Server...")
     
     # Initialize the server
     async with stdio_server() as (read_stream, write_stream):
@@ -508,31 +428,6 @@ async def main_stdio():
             )
         )
 
-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__":
-    main()
+    asyncio.run(main())