Version 1

app.py

@@ -1,280 +1,15 @@
-import gradio as gr
 import os
 import sys
 
-# Plus besoin du sys.path hack car on est à la racine
-# sys.path.append(os.path.abspath(os.path.join(os.path.dirname(__file__), "../..")))
+# Ajoute le dossier courant au path pour pouvoir importer src
+sys.path.append(os.path.dirname(__file__))
 
-from src.mcp_server import tools
-from src.mcp_server.playground import get_playground_ui_handlers
-from src.core.builder.proposal_generator import proposal_generator
+# Importe l'interface Gradio depuis le serveur
+# Note: Assurez-vous que src/mcp_server/server.py définit bien une variable 'demo' (gr.Blocks)
+from src.mcp_server.server import demo
 
-# --- Wrappers pour Gradio UI ---
-# Ces wrappers permettent d'avoir une UI conviviale tout en exposant les fonctions via MCP
-
-def init_and_propose_ui(project_name, description, type, model_id, provider_id):
-    """
-    Step 1 (Initialization): Starts a new tool project and uses AI to propose code.
-    
-    This is the entry point for creating a new MCP tool. It returns a draft_id and a code proposal based on the description.
-    
-    Args:
-        project_name: The technical name of the tool (e.g., 'weather-fetcher').
-        description: A natural language description of what the tool should do, or a raw Swagger/OpenAPI JSON specification.
-        type: The type of tool pattern (e.g., 'adhoc' for custom logic, 'api_wrapper' for REST clients).
-        model_id: The LLM model to use for code generation (default: Qwen/Qwen2.5-Coder-32B-Instruct).
-        provider_id: The inference provider to use (optional, e.g. 'together', 'fal-ai').
-    """
-    # 1. Initialisation du projet
-    init_result = tools.init_project(project_name, description, type)
-    draft_id = init_result.get("draft_id", "")
-    
-    # 2. Génération de la proposition par LLM
-    print(f"🤖 Génération de la proposition pour : {project_name} (Model: {model_id}, Provider: {provider_id})...")
-    proposal = proposal_generator.generate_from_description(project_name, description, model=model_id, provider=provider_id)
-    
-    # 3. Retourne les données pour mettre à jour l'UI
-    # Gère le cas où 'requirements' n'est pas renvoyé par le LLM
-    reqs = proposal.get("requirements", [])
-    
-    return (
-        init_result,                # out_init (JSON)
-        draft_id,                   # draft_id_logic (Textbox)
-        proposal["python_code"],    # python_code (Code)
-        proposal["inputs"],         # inputs_dict (JSON)
-        proposal["output_desc"],    # output_desc (Textbox)
-        reqs                        # requirements_box (JSON/List)
-    )
-
-def define_logic_ui(draft_id, python_code, inputs, output_desc, requirements):
-    """
-    Step 2 (Logic Definition): Validates and saves the tool code.
-    
-    Call this AFTER `init_and_propose_ui`. It saves the Python implementation into the draft before deployment.
-    
-    Args:
-        draft_id: The unique ID of the project draft (returned by Step 1).
-        python_code: The complete Python source code for the tool function.
-        inputs: A dictionary describing the input parameters (e.g. {"city": "Name of the city"}).
-        output_desc: A description of what the tool returns.
-        requirements: A list of Python dependencies (pip packages) required by the code (e.g. ["requests", "pandas"]).
-    """
-    # inputs est reçu comme un dictionnaire (via gr.JSON)
-    result = tools.define_logic(draft_id, python_code, inputs, output_desc, requirements)
-    return result
-
-def deploy_to_space_ui(draft_id, visibility, space_target, target_space_name):
-    """
-    Step 3 (Deployment): Deploys the tool to a Hugging Face Space.
-    
-    Call this AFTER `define_logic_ui`. It creates or updates a Space with the tool's code.
-    
-    Args:
-        draft_id: The unique ID of the project draft (from Step 1).
-        visibility: The visibility of the deployed Space ('public' or 'private').
-        space_target: Deployment strategy. 'new' creates a dedicated Space (Toolbox), 'existing' adds the tool to an existing Toolbox Space.
-        target_space_name: The name of the target Space. Required if space_target='existing'. Optional for 'new' (defaults to project name).
-    """
-    result = tools.deploy_to_space(draft_id, visibility, space_target, target_space_name)
-    return result
-
-# Récupération des handlers du playground
-reload_tools_handler, chat_response_handler = get_playground_ui_handlers()
-
-# --- Exposition des outils MCP (API pure) ---
-# Ces fonctions sont exposées directement aux LLMs via MCP, en plus de l'UI
-
-def mcp_propose_implementation(project_name: str, description: str):
-    """
-    [AI Assistant Only] Generates a Python implementation proposal without initializing a UI draft.
-    
-    Use this tool if you are an AI agent wanting to generate code from a spec before deciding to create a draft.
-    
-    Args:
-        project_name: Name of the intended tool.
-        description: The tool description or Swagger/OpenAPI specification.
-    """
-    return tools.propose_implementation(project_name, description)
-
-# --- Construction de l'interface ---
-
-with gr.Blocks(title="Meta-MCP Fractal") as demo:
-    gr.Markdown("# 🏭 Méta-MCP Fractal Factory")
-    gr.Markdown("Ce serveur permet de créer et déployer d'autres serveurs MCP sur Hugging Face Spaces.")
-
-    with gr.Tab("1. Initialisation"):
-        gr.Markdown("Commencez par initialiser un nouveau projet.")
-        
-        project_name = gr.Textbox(label="Nom du projet (ex: strawberry-counter, ratp-api-client)")
-        
-        project_desc = gr.Textbox(
-            label="Description de l'outil ou Spécification (Swagger/OpenAPI JSON)",
-            lines=10,
-            placeholder="Décrivez ce que doit faire l'outil, ou collez ici le contenu d'un fichier swagger.json pour générer un client API automatiquement."
-        )
-        
-        with gr.Row():
-            project_type = gr.Dropdown(choices=["adhoc", "api_wrapper"], value="adhoc", label="Type")
-        
-        with gr.Accordion("Paramètres IA (Avancé)", open=False):
-            model_id = gr.Textbox(label="Modèle LLM", value="Qwen/Qwen2.5-Coder-32B-Instruct")
-            provider_id = gr.Dropdown(
-                label="Provider d'Inférence", 
-                choices=["None", "together", "fal-ai", "replicate", "sambanova", "hyperbolic"], 
-                value="None",
-                info="Sélectionnez un provider spécifique si 'None' (auto) échoue."
-            )
-
-        btn_init = gr.Button("Initialiser le projet & Générer le code (IA)")
-        out_init = gr.JSON(label="Résultat (Copiez le draft_id)")
-        
-
-    with gr.Tab("2. Définition de la logique"):
-        gr.Markdown("Définissez le code Python et l'interface de votre outil.")
-        with gr.Row():
-            draft_id_logic = gr.Textbox(label="Draft ID")
-            python_code = gr.Code(language="python", label="Code Python (ex: def count_r(word): ...)")
-        
-        with gr.Row():
-            inputs_dict = gr.JSON(label="Inputs (ex: {'word': 'text'})", value={"word": "text"})
-            output_desc = gr.Textbox(label="Description de la sortie")
-            
-        requirements_box = gr.JSON(label="Requirements (Pip packages)", value=[])
-            
-        btn_logic = gr.Button("Générer le code")
-        out_logic = gr.JSON(label="Résultat")
-        
-        btn_logic.click(define_logic_ui, inputs=[draft_id_logic, python_code, inputs_dict, output_desc, requirements_box], outputs=out_logic)
-
-    with gr.Tab("3. Déploiement"):
-        gr.Markdown("Déployez votre outil sur Hugging Face Spaces.")
-        with gr.Row():
-            draft_id_deploy = gr.Textbox(label="Draft ID")
-            visibility = gr.Dropdown(choices=["public", "private"], value="public", label="Visibilité")
-        
-        gr.Markdown("---")
-        gr.Markdown("### 🎯 Cible du déploiement")
-        
-        with gr.Row():
-            space_target = gr.Radio(
-                choices=["new", "existing"], 
-                value="new", 
-                label="Mode de déploiement",
-                info="Choisissez si vous créez une nouvelle Toolbox ou si vous enrichissez une existante."
-            )
-            
-            # Ce champ sert pour les deux cas : soit pour nommer la nouvelle toolbox, soit pour cibler l'existante
-            target_space_name = gr.Textbox(
-                label="Nom du Space Cible", 
-                placeholder="Laissez vide pour utiliser le nom du projet, ou saisissez un nom (ex: ma-toolbox)",
-                visible=True,
-                info="Si 'new' : Nom de la nouvelle Toolbox (facultatif). Si 'existing' : Nom du Space à mettre à jour (obligatoire)."
-            )
-            
-        # Petit helper pour changer le label/placeholder selon le mode (UX improvement)
-        def update_space_field(target):
-            if target == "new":
-                return gr.update(
-                    label="Nom de la nouvelle Toolbox (Optionnel)", 
-                    placeholder="Laissez vide pour utiliser le nom du projet (ex: strawberry-counter)"
-                )
-            else:
-                return gr.update(
-                    label="Nom du Space Existant (Obligatoire)", 
-                    placeholder="ex: username/my-toolbox"
-                )
-            
-        space_target.change(fn=update_space_field, inputs=space_target, outputs=target_space_name)
-
-        btn_deploy = gr.Button("Déployer sur Spaces", variant="primary")
-        out_deploy = gr.JSON(label="Résultat du déploiement")
-        
-        btn_deploy.click(
-            deploy_to_space_ui, 
-            inputs=[draft_id_deploy, visibility, space_target, target_space_name], 
-            outputs=out_deploy
-        )
-
-    # Câblage global des événements (une fois tous les composants définis)
-    # 1. Init -> Remplissage auto de l'onglet 2 (Logic) et copie de l'ID vers onglet 3 (Deploy)
-    btn_init.click(
-        init_and_propose_ui, 
-        inputs=[project_name, project_desc, project_type, model_id, provider_id], 
-        outputs=[out_init, draft_id_logic, python_code, inputs_dict, output_desc, requirements_box]
-    ).then(
-        fn=lambda x: x,
-        inputs=[draft_id_logic],
-        outputs=[draft_id_deploy]
-    )
-
-    with gr.Tab("4. Test & Playground (Smolagents)"):
-        gr.Markdown("Testez immédiatement votre serveur MCP déployé.")
-        
-        with gr.Row():
-            mcp_url_input = gr.Textbox(
-                label="URL du Serveur MCP", 
-                placeholder="ex: https://votre-user-votre-space.hf.space/gradio_api/mcp/sse",
-                scale=3
-            )
-            btn_reload = gr.Button("🔄 Charger les outils", scale=1)
-        
-        status_msg = gr.Markdown("")
-        tool_table = gr.DataFrame(headers=["Tool name", "Description", "Params"], label="Outils détectés")
-        
-        gr.Markdown("### 🤖 Discutez avec votre Agent MCP")
-        chatbot = gr.ChatInterface(
-            fn=chat_response_handler
-        )
-
-        btn_reload.click(
-            fn=reload_tools_handler,
-            inputs=[mcp_url_input],
-            outputs=[tool_table, status_msg],
-            api_name=False # Hide internal tool
-        )
-        
-    # Exposition explicite des outils pour les agents MCP sans UI
-    # Cela permet à ChatGPT/Claude d'appeler ces fonctions directement
-    # Note: Les fonctions liées à l'UI sont déjà exposées, mais celles-ci sont plus propres pour une API.
-    # Gradio expose automatiquement les fonctions utilisées dans l'interface, mais on peut ajouter des endpoints API spécifiques.
-    # Cependant, avec mcp_server=True, Gradio expose TOUT ce qui est triggué.
-    # Pour être sûr que 'propose_implementation' est dispo, on l'ajoute via un composant invisible ou une API route si possible.
-    # Dans la version actuelle de Gradio MCP, seules les fonctions liées à des événements sont exposées.
-    # On va donc créer une "API Box" invisible pour exposer cet outil spécifique.
-    
-    with gr.Accordion("API Tools (Invisible)", visible=False):
-        api_input_name = gr.Textbox()
-        api_input_desc = gr.Textbox()
-        api_output = gr.JSON()
-        
-        btn_api_propose = gr.Button("Propose Implementation API")
-        btn_api_propose.click(
-            mcp_propose_implementation,
-            inputs=[api_input_name, api_input_desc],
-            outputs=[api_output],
-            api_name="propose_implementation" # Nom de l'outil pour le LLM
-        )
-
-# --- Définition des Ressources et Prompts MCP ---
-
-# On active les décorateurs s'ils sont dispos
-if hasattr(gr, "mcp"):
-    @gr.mcp.resource("list://drafts")
-    def list_active_drafts() -> str:
-        """Returns a list of currently active project drafts."""
-        # Note: In a real app, this would query the session manager
-        return "Active Drafts: [draft_id_1, draft_id_2]"
-
-    @gr.mcp.prompt()
-    def help_create_tool(topic: str = "general") -> str:
-        """
-        Provides a prompt template to help users create a new tool.
-        Args:
-            topic: The topic of the tool (e.g. 'data', 'fun', 'utility')
-        """
-        return f"I want to create a new MCP tool related to {topic}. Can you guide me through the initialization, logic definition, and deployment steps using the available tools?"
-
-# Point d'entrée
 if __name__ == "__main__":
-    # Lancement avec mcp_server=True pour exposer les outils aux LLMs
-    demo.launch(show_error=True, mcp_server=True)
+    # Lancement du serveur compatible Hugging Face Spaces
+    # mcp_server=True active les endpoints MCP
+    # show_error=True permet de voir les erreurs Python dans l'interface (utile pour le débug)
+    demo.launch(server_name="0.0.0.0", server_port=7860, mcp_server=True, show_error=True)

src/mcp_server/server.py

@@ -31,9 +31,12 @@ def step_1_initialisation_and_proposal(project_name, description, type, model_id
     draft_id = init_result.get("draft_id", "")
     
     # 2. Génération de la proposition par LLM
+    gr.Info("Génération du code par l'IA en cours...")
     print(f"🤖 Génération de la proposition pour : {project_name} (Model: {model_id}, Provider: {provider_id})...")
     proposal = proposal_generator.generate_from_description(project_name, description, model=model_id, provider=provider_id)
     
+    gr.Info("Proposition générée ! Veuillez valider dans l'onglet suivant.")
+    
     # 3. Retourne les données pour mettre à jour l'UI
     # Gère le cas où 'requirements' n'est pas renvoyé par le LLM
     reqs = proposal.get("requirements", [])
@@ -68,6 +71,12 @@ def step_2_logic_definition(draft_id, python_code, inputs, output_desc, requirem
     print(f"DEBUG [step_2_logic_definition]: inputs type={type(inputs)}")
     
     result = tools.define_logic(draft_id, python_code, inputs, output_desc, requirements)
+    
+    if "error" not in result:
+        gr.Info("Code validé et enregistré ! Prêt à déployer.")
+    else:
+        gr.Info(f"Erreur : {result['error']}")
+        
     return result
 
 def step_3_deployment(draft_id):
@@ -79,8 +88,15 @@ def step_3_deployment(draft_id):
     Args:
         draft_id: The unique ID of the project draft (from Step 1).
     """
+    gr.Info("Déploiement en cours... Cela peut prendre quelques minutes.")
     # Simplification: Toujours public, toujours new (écrase/crée), nom du space = nom du projet
     result = tools.deploy_to_space(draft_id, visibility="public", space_target="new", target_space_name=None)
+    
+    if "error" not in result:
+        gr.Info(f"Déploiement réussi ! URL : {result.get('url')}")
+    else:
+        gr.Info(f"Échec du déploiement : {result.get('error')}")
+        
     return result
 
 # Récupération des handlers du playground
@@ -191,6 +207,7 @@ with gr.Blocks(title="Meta-MCP Fractal") as demo:
             if user: os.environ["HF_USER"] = user
             if space: os.environ["DEFAULT_SPACE"] = space
             if token: os.environ["HF_TOKEN"] = token
+            gr.Info("Configuration sauvegardée !")
             return f"Configuration saved! User: {user}, Default Space: {space}"
             
         config_status = gr.Markdown("")
@@ -320,8 +337,6 @@ with gr.Blocks(title="Meta-MCP Fractal") as demo:
                         if "/" in path:
                             user, space = path.split("/", 1)
                             # Format direct url : https://user-space.hf.space
-                            # Note: le nom du space dans l'url doit être en minuscules et les _ deviennent - parfois, mais HF gère la redirection souvent.
-                            # Pour être sûr, on garde la structure simple.
                             direct_url = f"https://{user}-{space}.hf.space/gradio_api/mcp/"
                             return direct_url
             except:
@@ -330,18 +345,6 @@ with gr.Blocks(title="Meta-MCP Fractal") as demo:
             # Fallback si parsing échoue
             return hf_url
 
-        btn_deploy.click(
-            step_3_deployment, 
-            inputs=[draft_id_deploy], 
-            outputs=out_deploy,
-            api_name="step_3_deployment"
-        ).then(
-            fn=auto_fill_playground,
-            inputs=[out_deploy],
-            outputs=[mcp_url_input],
-            api_name=False
-        )
-
     # Câblage global des événements (une fois tous les composants définis)
     # 1. Init -> Remplissage auto de l'onglet 2 (Logic) et copie de l'ID vers onglet 3 (Deploy)
     btn_init.click(
@@ -359,7 +362,7 @@ with gr.Blocks(title="Meta-MCP Fractal") as demo:
     with gr.Tab("4. Test & Playground (Smolagents)"):
         gr.Markdown("Testez immédiatement votre serveur MCP déployé.")
         
-        with gr.Row():
+        with gr.Column():
             mcp_url_input = gr.Textbox(
                 label="URL du Serveur MCP", 
                 placeholder="ex: https://votre-user-votre-space.hf.space/gradio_api/mcp/sse",
@@ -368,7 +371,24 @@ with gr.Blocks(title="Meta-MCP Fractal") as demo:
             btn_reload = gr.Button("🔄 Charger les outils", scale=1)
         
         status_msg = gr.Markdown("")
-        tool_table = gr.DataFrame(headers=["Tool name", "Description", "Params"], label="Outils détectés")
+        
+        # Tableau adapté pour l'affichage des outils (wrap=True)
+        tool_table = gr.DataFrame(
+            headers=["Tool name", "Description", "Params"], 
+            label="Outils détectés",
+            wrap=True,
+            interactive=False
+        )
+        
+        gr.Markdown("""
+        ### ⚙️ Configuration Smolagents
+        Pour utiliser cet outil avec smolagents dans votre code :
+        ```python
+        from smolagents import MCPClient
+        # Mode HTTP direct (recommandé)
+        client = MCPClient(url="URL_DU_SERVEUR", structured_output=False) 
+        ```
+        """)
         
         gr.Markdown("### 🤖 Discutez avec votre Agent MCP")
         chatbot = gr.ChatInterface(
@@ -382,6 +402,19 @@ with gr.Blocks(title="Meta-MCP Fractal") as demo:
             api_name=False # Hide internal tool
         )
         
+    # Câblage différé du déploiement (pour avoir accès à mcp_url_input défini dans le Tab 4)
+    btn_deploy.click(
+        step_3_deployment, 
+        inputs=[draft_id_deploy], 
+        outputs=out_deploy,
+        api_name="step_3_deployment"
+    ).then(
+        fn=auto_fill_playground,
+        inputs=[out_deploy],
+        outputs=[mcp_url_input],
+        api_name=False
+    )
+
     # Exposition explicite des outils pour les agents MCP sans UI
     # Cela permet à ChatGPT/Claude d'appeler ces fonctions directement
     # Note: Les fonctions liées à l'UI sont déjà exposées, mais celles-ci sont plus propres pour une API.

src/mcp_server/tools.py

@@ -1,6 +1,8 @@
 from typing import Dict, Any, Union
 import json
 import os
+from huggingface_hub import hf_hub_download
+from huggingface_hub.utils import EntryNotFoundError, RepositoryNotFoundError
 
 from src.core.state.session_manager import SessionManager
 from src.core.builder.code_generator import CodeGenerator
@@ -157,8 +159,40 @@ def deploy_to_space(draft_id: str, visibility: str = "public", space_target: str
     if space_target == "existing":
         if "app.py" in files_to_deploy:
             del files_to_deploy["app.py"]
+            
+        # Fusion intelligente des requirements
         if "requirements.txt" in files_to_deploy:
-            del files_to_deploy["requirements.txt"]
+            new_reqs = set(files_to_deploy["requirements.txt"].splitlines())
+            
+            try:
+                print(f"DEBUG: Tentative de récupération des requirements existants sur {final_space_name}...")
+                # Téléchargement du requirements.txt existant
+                cached_path = hf_hub_download(
+                    repo_id=final_space_name,
+                    filename="requirements.txt",
+                    repo_type="space",
+                    token=deployer.token
+                )
+                with open(cached_path, 'r') as f:
+                    existing_reqs = set(f.read().splitlines())
+                
+                # Fusion (Union)
+                merged_reqs = existing_reqs.union(new_reqs)
+                # Nettoyage (lignes vides)
+                merged_content = "\n".join(sorted([r for r in merged_reqs if r.strip()]))
+                
+                files_to_deploy["requirements.txt"] = merged_content
+                print(f"DEBUG: Requirements fusionnés avec succès ({len(existing_reqs)} existants + nouveaux).")
+                
+            except (EntryNotFoundError, RepositoryNotFoundError):
+                print("DEBUG: Pas de requirements.txt existant ou repo introuvable, utilisation des nouveaux uniquement.")
+                # Le fichier n'existe pas encore, on garde celui du draft
+                pass
+            except Exception as e:
+                print(f"DEBUG: Erreur lors de la fusion des requirements: {e}")
+                # En cas d'erreur, on garde les nouveaux pour ne pas bloquer, 
+                # mais on pourrait aussi choisir d'échouer. Ici on force l'ajout.
+                pass
             
     try:
         url = deployer.deploy_space(
@@ -187,7 +221,6 @@ def deploy_to_space(draft_id: str, visibility: str = "public", space_target: str
             "{server_name}": {{
               "command": "npx",
               "args": [
-                "-y",
                 "mcp-remote",
                 "{mcp_endpoint}",
                 "--transport",