Premiere version de MCEPTION :)

.gitignore

@@ -0,0 +1,51 @@
+# Python
+__pycache__/
+*.py[cod]
+*$py.class
+*.so
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# Virtual Environment
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# IDE
+.vscode/
+.idea/
+
+# Local Data & References (Swagger, CSV, etc.)
+data/*
+!data/references/
+!data/uploads/
+
+# Ignore contents of data subdirectories but keep gitkeep files
+data/references/*
+!data/references/.gitkeep
+
+data/uploads/*
+!data/uploads/.gitkeep
+
+# Sensitive Information
+secrets.yaml

README.md

@@ -1,13 +0,0 @@
----
-title: Metamcp Proto
-emoji: 🏢
-colorFrom: red
-colorTo: pink
-sdk: gradio
-sdk_version: 6.0.0
-app_file: app.py
-pinned: false
-short_description: 'Prototype '
----
-
-Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,13 @@
+import os
+import sys
+import gradio as gr
+
+# Ajoute le dossier courant au path pour les imports relatifs
+sys.path.append(os.path.dirname(__file__))
+
+# Importe l'interface Gradio depuis le serveur
+from src.mcp_server.server import demo
+
+if __name__ == "__main__":
+    # Lance le serveur (Gradio gère automatiquement le port sur Spaces)
+    demo.launch(server_name="0.0.0.0", server_port=7860, mcp_server=True, show_error=True)

requirements.txt

@@ -0,0 +1,7 @@
+gradio>=5.0.0
+mcp>=1.0.0
+huggingface_hub>=0.26.0
+python-dotenv>=1.0.0
+smolagents[mcp]>=1.0.0
+pandas>=2.0.0
+requests>=2.31.0

src/core/builder/code_generator.py

@@ -0,0 +1,173 @@
+import textwrap
+
+class CodeGenerator:
+    @staticmethod
+    def generate_gradio_app(function_code: str, inputs: dict, output_desc: str) -> str:
+        """
+        Génère le code complet d'une application Gradio à partir d'un snippet de fonction.
+        
+        Args:
+            function_code: Le code source de la fonction principale (ex: def count_r(word): ...)
+            inputs: Dict décrivant les inputs (ex: {"word": "text"})
+            output_desc: Description de l'output
+            
+        Returns:
+            Le code source complet de app.py
+        """
+        
+        # Analyse simple pour trouver le nom de la fonction (très naïf pour l'instant)
+        # On suppose que le code contient "def nom_fonction("
+        import re
+        match = re.search(r"def\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(", function_code)
+        func_name = match.group(1) if match else "main_function"
+
+        # Mapping des types MCP/JSON vers types Gradio
+        # Pour simplifier, on mappe tout sur Text pour l'instant ou on utilise les strings directs
+        # TODO: Améliorer le mapping des types
+        
+        # Construction du code
+        template = f"""
+import gradio as gr
+import json
+
+# --- User Defined Logic ---
+{function_code}
+
+# --- Gradio Interface ---
+
+# Wrapper pour gérer les types si nécessaire
+def wrapper(*args):
+    result = {func_name}(*args)
+    return str(result) # Force string output for simplicity
+
+# Configuration des inputs Gradio
+# Note: Cette partie est générique pour le MVP.
+# Idéalement, on itère sur 'inputs' pour créer les composants Gradio correspondants.
+
+iface = gr.Interface(
+    fn=wrapper,
+    inputs=[gr.Textbox(label=k) for k in {list(inputs.keys())}],
+    outputs=gr.Textbox(label="{output_desc}"),
+    title="Meta-MCP Generated Tool",
+    description="Auto-generated by Meta-MCP Fractal"
+)
+
+if __name__ == "__main__":
+    iface.launch(mcp_server=True, show_error=True)
+"""
+        return textwrap.dedent(template).strip()
+
+    @staticmethod
+    def generate_tool_module(function_code: str, inputs: dict, output_desc: str, tool_name: str) -> str:
+        """
+        Génère un module Python contenant la logique de l'outil et une factory d'interface.
+        Destiné à être placé dans le dossier 'tools/'.
+        """
+        import re
+        match = re.search(r"def\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(", function_code)
+        func_name = match.group(1) if match else "main_function"
+
+        template = f"""
+import gradio as gr
+import json
+
+# --- User Defined Logic ---
+{function_code}
+
+# --- Interface Factory ---
+def create_interface():
+    # On utilise directement la fonction utilisateur pour préserver la signature et la docstring
+    # Cela permet à Gradio de générer une documentation MCP correcte.
+    return gr.Interface(
+        fn={func_name},
+        inputs=[gr.Textbox(label=k) for k in {list(inputs.keys())}],
+        outputs=gr.Textbox(label="{output_desc}"),
+        title="{tool_name}",
+        description="Auto-generated tool: {tool_name}"
+    )
+"""
+        return textwrap.dedent(template).strip()
+
+    @staticmethod
+    def generate_master_app() -> str:
+        """
+        Génère le fichier app.py principal.
+        Utilise une approche standard avec import dynamique simple.
+        """
+        template = """
+import gradio as gr
+import os
+import sys
+import importlib
+
+# Configuration
+TOOLS_DIR = "tools"
+
+# S'assurer que le dossier tools existe et est un package
+if not os.path.exists(TOOLS_DIR):
+    os.makedirs(TOOLS_DIR, exist_ok=True)
+    with open(os.path.join(TOOLS_DIR, "__init__.py"), "w") as f:
+        pass
+
+# Ajouter le répertoire courant au path pour que 'import tools.xxx' fonctionne
+sys.path.append(os.path.dirname(os.path.abspath(__file__)))
+
+interfaces = []
+names = []
+
+print(f"🚀 Starting Meta-MCP Toolbox...")
+print(f"📂 Scanning '{TOOLS_DIR}' directory...")
+
+# Scan et import des outils
+try:
+    for filename in sorted(os.listdir(TOOLS_DIR)):
+        if filename.endswith(".py") and not filename.startswith("_"):
+            module_name = filename[:-3]
+            full_module_name = f"{TOOLS_DIR}.{module_name}"
+            
+            try:
+                print(f"  👉 Importing {full_module_name}...")
+                # Import dynamique standard
+                # On utilise reload pour être sûr de prendre la dernière version si redémarrage
+                module = importlib.import_module(full_module_name)
+                importlib.reload(module)
+                
+                if hasattr(module, "create_interface"):
+                    # Création de l'interface Gradio pour cet outil
+                    tool_interface = module.create_interface()
+                    interfaces.append(tool_interface)
+                    names.append(module_name)
+                    print(f"  ✅ Loaded {module_name}")
+                else:
+                    print(f"  ⚠️ Module {module_name} has no create_interface()")
+            except Exception as e:
+                print(f"  ❌ Error loading {module_name}: {e}")
+                import traceback
+                traceback.print_exc()
+
+except Exception as e:
+    print(f"Error scanning tools directory: {e}")
+
+# Construction de l'interface finale
+if not interfaces:
+    demo = gr.Interface(
+        fn=lambda x: "No tools loaded yet. Add a tool via Meta-MCP!", 
+        inputs="text", 
+        outputs="text", 
+        title="Empty Toolbox",
+        description="This Space is ready to receive tools."
+    )
+else:
+    demo = gr.TabbedInterface(interfaces, names)
+
+if __name__ == "__main__":
+    demo.launch(mcp_server=True, show_error=True)
+"""
+        return textwrap.dedent(template).strip()
+
+    @staticmethod
+    def generate_mcp_server_code(function_code: str) -> str:
+        """
+        Génère un serveur MCP (FastMCP) au lieu de Gradio (Future feature).
+        """
+        pass

src/core/builder/proposal_generator.py

@@ -0,0 +1,94 @@
+import os
+import json
+from huggingface_hub import InferenceClient
+
+class ProposalGenerator:
+    def __init__(self):
+        self.token = os.environ.get("HF_TOKEN")
+        # Client par défaut
+        self.client = InferenceClient(token=self.token)
+
+    def generate_from_description(self, project_name: str, description: str, model: str = "Qwen/Qwen2.5-Coder-32B-Instruct", provider: str = None):
+        """
+        Génère une proposition de code et de configuration à partir d'une description.
+        Utilise chat_completion pour une meilleure compatibilité.
+        """
+        
+        # Configuration dynamique du client si nécessaire (ex: changement de provider)
+        # Note: InferenceClient est léger, on peut l'instancier à la demande ou utiliser l'existant
+        # Si provider est spécifié, on l'utilise. Sinon on laisse HF choisir.
+        # "None" string from UI should be converted to None type
+        if provider == "None" or provider == "":
+            provider = None
+            
+        print(f"🤖 Appel LLM avec Modèle: {model}, Provider: {provider}")
+        
+        client = InferenceClient(model=model, token=self.token, provider=provider)
+        
+        messages = [
+            {
+                "role": "system", 
+                "content": """You are an expert Python developer creating a tool for an MCP server via Gradio.
+Your goal is to generate production-ready Python code that is fully typed and documented.
+You MUST return ONLY a valid JSON object."""
+            },
+            {
+                "role": "user",
+                "content": f"""Create a tool named '{project_name}' that does the following: {description}
+
+Requirements:
+1. The function MUST have a clear and descriptive docstring (Google style preferred) explaining what it does, its arguments, and its return value. This docstring will be used as the tool description for the LLM.
+2. The function arguments MUST be fully typed (e.g. `word: str`, `count: int`).
+3. The function return type MUST be specified (e.g. `-> str`).
+4. The function name should match '{project_name}' (normalized to python snake_case).
+5. If the code requires external libraries (like `requests`, `pandas`, `numpy`), list them.
+
+Return ONLY a valid JSON object with the following structure:
+{{
+    "python_code": "def function_name(arg1: type) -> type:\\n    \\"\\"\\"Docstring here...\\"\\"\\"\\n    ...",
+    "inputs": {{ "arg1": "Description for UI label" }},
+    "output_desc": "Description for UI label of the output",
+    "requirements": ["requests", "pandas"] 
+}}
+
+Make sure the python_code is a valid, complete, standalone Python function with all necessary imports inside (e.g. `import requests` inside the function or at top level if compatible).
+If the user provides an API Specification (Swagger/OpenAPI), generate a client function that implements the main operation described.
+Do not use markdown formatting (no ```json). Just the raw JSON string.
+"""
+            }
+        ]
+        
+        try:
+            response = client.chat_completion(
+                messages, 
+                max_tokens=1024, 
+                temperature=0.2,
+                stream=False
+            )
+            
+            # Extraction du contenu
+            content = response.choices[0].message.content.strip()
+            
+            # Nettoyage basique pour extraire le JSON si le modèle bavarde un peu
+            if content.startswith("```json"):
+                content = content[7:]
+            elif content.startswith("```"):
+                content = content[3:]
+            if content.endswith("```"):
+                content = content[:-3]
+            
+            return json.loads(content.strip())
+            
+        except Exception as e:
+            print(f"Error generating proposal: {e}")
+            import traceback
+            traceback.print_exc()
+            # Fallback en cas d'erreur
+            return {
+                "python_code": f"# Error generating code: {str(e)}\n# Try changing the Inference Provider or Model.\ndef {project_name.replace('-', '_')}():\n    return 'Error'",
+                "inputs": {},
+                "output_desc": "Error fallback"
+            }
+
+# Singleton
+proposal_generator = ProposalGenerator()

src/core/deployer/huggingface.py

@@ -0,0 +1,122 @@
+import os
+from typing import Dict, Optional
+from huggingface_hub import HfApi, get_token
+
+class HFDeployer:
+    def __init__(self, token: Optional[str] = None):
+        """
+        Initialise le déployeur Hugging Face.
+        Si token est None, essaie de le récupérer depuis l'environnement HF_TOKEN
+        ou le cache local.
+        """
+        self.token = token or os.environ.get("HF_TOKEN") or get_token()
+        if not self.token:
+            raise ValueError("Aucun token Hugging Face trouvé. Veuillez définir HF_TOKEN.")
+        
+        self.api = HfApi(token=self.token)
+
+    def _sanitize_repo_id(self, input_name: str, current_username: str) -> str:
+        """Nettoie le nom du repo/space pour gérer les URLs et les formats partiels."""
+        input_name = input_name.strip()
+        
+        # Cas URL complète : https://huggingface.co/spaces/user/repo
+        if "huggingface.co" in input_name:
+            parts = input_name.split("huggingface.co/")
+            if len(parts) > 1:
+                path = parts[1]
+                # Retire 'spaces/' si présent
+                if path.startswith("spaces/"):
+                    path = path[7:]
+                # Retire le slash final
+                return path.rstrip("/")
+        
+        # Cas user/repo
+        if "/" in input_name:
+            return input_name
+            
+        # Cas repo seul -> user/repo
+        return f"{current_username}/{input_name}"
+
+    def deploy_space(self, 
+                     space_name: str, 
+                     files: Dict[str, str], 
+                     username: Optional[str] = None,
+                     sdk: str = "gradio", 
+                     private: bool = False) -> str:
+        """
+        Crée un Space et déploie les fichiers.
+        
+        Args:
+            space_name: Nom du space (ex: 'strawberry-counter')
+            files: Dictionnaire {nom_fichier: contenu} (ex: {'app.py': '...'})
+            username: Nom d'utilisateur ou organisation cible. Si None, utilise l'utilisateur courant.
+            sdk: 'gradio', 'streamlit', ou 'docker'
+            private: Si True, crée un repo privé
+            
+        Returns:
+            L'URL du Space déployé.
+        """
+        
+        # 1. Déterminer le repo_id complet
+        if not username:
+            user_info = self.api.whoami()
+            username = user_info["name"]
+        
+        # Utilisation de la méthode de nettoyage
+        repo_id = self._sanitize_repo_id(space_name, username)
+        
+        print(f"🚀 Préparation du déploiement vers {repo_id}...")
+
+        # 2. Création du repo (idempotent: ne plante pas s'il existe déjà)
+        try:
+            self.api.create_repo(
+                repo_id=repo_id,
+                repo_type="space",
+                space_sdk=sdk,
+                private=private,
+                exist_ok=True
+            )
+            print(f"✅ Repo {repo_id} prêt.")
+        except Exception as e:
+            raise RuntimeError(f"Erreur lors de la création du repo: {str(e)}")
+
+        # 3. Upload des fichiers
+        operations = []
+        for filename, content in files.items():
+            # On encode le contenu en bytes pour l'upload
+            content_bytes = content.encode("utf-8")
+            operations.append(
+                self.api.run_as_future(
+                    self.api.upload_file,
+                    path_or_fileobj=content_bytes,
+                    path_in_repo=filename,
+                    repo_id=repo_id,
+                    repo_type="space"
+                )
+            )
+
+        # Note: Pour simplifier ici on fait séquentiel ou on utilise upload_file direct.
+        # Pour un vrai batch, commit_operation serait mieux, mais upload_file est simple pour démarrer.
+        # Re-implémentation propre avec upload_file direct pour éviter complexité async pour l'instant
+        
+        try:
+            for filename, content in files.items():
+                print(f"📤 Upload de {filename}...")
+                content_bytes = content.encode("utf-8")
+                self.api.upload_file(
+                    path_or_fileobj=content_bytes,
+                    path_in_repo=filename,
+                    repo_id=repo_id,
+                    repo_type="space",
+                    commit_message=f"Deploy {filename} via Meta-MCP"
+                )
+            print("✅ Tous les fichiers ont été uploadés.")
+        except Exception as e:
+             raise RuntimeError(f"Erreur lors de l'upload des fichiers: {str(e)}")
+
+        # 4. Construction de l'URL
+        # L'URL standard est https://huggingface.co/spaces/USERNAME/SPACE_NAME
+        space_url = f"https://huggingface.co/spaces/{repo_id}"
+        
+        print(f"🎉 Déploiement terminé ! Space accessible ici : {space_url}")
+        return space_url

src/core/state/session_manager.py

@@ -0,0 +1,49 @@
+import uuid
+from typing import Dict, Any, Optional
+from dataclasses import dataclass, field
+from datetime import datetime
+
+@dataclass
+class ProjectDraft:
+    draft_id: str
+    name: str
+    description: str
+    type: str
+    created_at: datetime = field(default_factory=datetime.now)
+    code_files: Dict[str, str] = field(default_factory=dict)
+    metadata: Dict[str, Any] = field(default_factory=dict)
+
+class SessionManager:
+    def __init__(self):
+        self._drafts: Dict[str, ProjectDraft] = {}
+
+    def create_draft(self, name: str, description: str, type: str = "adhoc") -> ProjectDraft:
+        """Crée un nouveau brouillon de projet."""
+        draft_id = str(uuid.uuid4())
+        draft = ProjectDraft(
+            draft_id=draft_id,
+            name=name,
+            description=description,
+            type=type
+        )
+        # Initialisation des fichiers de base
+        draft.code_files["requirements.txt"] = "mcp"
+        
+        self._drafts[draft_id] = draft
+        return draft
+
+    def get_draft(self, draft_id: str) -> Optional[ProjectDraft]:
+        """Récupère un brouillon par son ID."""
+        return self._drafts.get(draft_id)
+
+    def update_code(self, draft_id: str, filename: str, content: str) -> bool:
+        """Met à jour un fichier de code dans le brouillon."""
+        draft = self.get_draft(draft_id)
+        if not draft:
+            return False
+        draft.code_files[filename] = content
+        return True
+
+    def list_drafts(self) -> Dict[str, str]:
+        """Liste tous les brouillons actifs."""
+        return {d.draft_id: d.name for d in self._drafts.values()}

src/mcp_server/playground.py

@@ -0,0 +1,124 @@
+import os
+import sys
+import io
+import re
+import pandas as pd
+import gradio as gr
+from contextlib import redirect_stdout
+from smolagents import InferenceClientModel, CodeAgent, Tool
+
+def remove_ansi_codes(text):
+    """Supprime les codes d'échappement ANSI (couleurs) du texte."""
+    ansi_escape = re.compile(r'\x1B(?:[@-Z\\-_]|\[[0-?]*[ -/]*[@-~])')
+    return ansi_escape.sub('', text)
+
+# Note: MCPClient n'est peut-être pas exposé directement par smolagents dans toutes les versions.
+# Si l'import échoue, il faudra peut-être utiliser une approche différente ou vérifier la version.
+# L'utilisateur a fourni `from smolagents import ..., MCPClient`, donc on suit cette voie.
+try:
+    from smolagents import MCPClient
+except ImportError:
+    # Fallback ou mock si MCPClient n'est pas encore dans la version installée
+    # Pour l'instant on assume que c'est bon comme demandé par l'user
+    MCPClient = None 
+
+class PlaygroundManager:
+    def __init__(self):
+        self.agent = None
+        self.tools = []
+        self.mcp_client = None
+
+    def load_mcp_tools(self, mcp_url: str):
+        """Connecte le client MCP à l'URL donnée et charge les outils."""
+        try:
+            # Nettoyage de l'ancien client
+            if self.mcp_client:
+                # self.mcp_client.disconnect() # Si méthode existe
+                pass
+            
+            # Initialisation du client MCP
+            # L'utilisateur a demandé d'ignorer le mode SSE et d'utiliser HTTP streamable
+            # On nettoie l'URL si elle contient encore /sse par erreur
+            if mcp_url.endswith("/sse"):
+                mcp_url = mcp_url[:-4]
+            
+            # On passe l'URL sans forcer le transport SSE, smolagents devrait gérer
+            # Note: On passe l'URL directement si possible, ou dans un dict selon l'API
+            # structured_output=False pour éviter le FutureWarning et rester compatible
+            self.mcp_client = MCPClient({"url": mcp_url}, structured_output=False) 
+            
+            # Récupération des outils
+            self.tools = self.mcp_client.get_tools()
+            
+            # Configuration de l'agent
+            # On utilise HF_TOKEN pour le modèle d'inférence
+            token = os.environ.get("HF_TOKEN")
+            if not token:
+                return pd.DataFrame({"Error": ["HF_TOKEN env var is missing"]}), "Error: HF_TOKEN missing"
+
+            model = InferenceClientModel(token=token)
+            self.agent = CodeAgent(tools=self.tools, model=model)
+            
+            # Création du DataFrame pour l'affichage
+            rows = []
+            for tool in self.tools:
+                # Gestion simplifiée des inputs pour l'affichage
+                input_desc = str(tool.inputs) if hasattr(tool, 'inputs') else "N/A"
+                rows.append({
+                    "Tool name": tool.name,
+                    "Description": tool.description,
+                    "Params": input_desc
+                })
+            
+            df = pd.DataFrame(rows)
+            return df, f"Succès ! {len(self.tools)} outils chargés depuis {mcp_url}"
+
+        except Exception as e:
+            import traceback
+            traceback.print_exc()
+            return pd.DataFrame({"Error": [str(e)]}), f"Erreur de connexion: {str(e)}"
+
+    def chat(self, message: str, history: list):
+        """Exécute le message utilisateur via l'agent en capturant la réflexion."""
+        if not self.agent:
+            return "⚠️ Veuillez d'abord charger un serveur MCP valide."
+        
+        # Capture de la sortie standard (logs de réflexion de smolagents)
+        f = io.StringIO()
+        try:
+            with redirect_stdout(f):
+                # L'agent smolagents s'exécute
+                # Note: Le streaming réel de la réflexion nécessiterait une intégration plus profonde avec smolagents
+                response = self.agent.run(message)
+            
+            # Nettoyage des logs (suppression des couleurs ANSI qui cassent le Markdown)
+            raw_logs = f.getvalue()
+            clean_logs = remove_ansi_codes(raw_logs)
+            
+            # Formatage de la réponse avec les logs de réflexion nettoyés
+            if clean_logs:
+                formatted_response = f"**💭 Réflexion de l'agent :**\n```text\n{clean_logs}\n```\n\n**✅ Réponse :**\n{str(response)}"
+            else:
+                formatted_response = str(response)
+                
+            return formatted_response
+            
+        except Exception as e:
+            raw_logs = f.getvalue()
+            clean_logs = remove_ansi_codes(raw_logs)
+            return f"Erreur lors de l'exécution de l'agent: {str(e)}\n\nLogs partiels:\n{clean_logs}"
+
+# Singleton pour gérer l'état du playground dans l'instance Gradio
+# Attention: Dans un vrai déploiement multi-utilisateurs, l'état devrait être géré par gr.State
+playground = PlaygroundManager()
+
+def get_playground_ui_handlers():
+    """Retourne les fonctions wrappers pour l'UI Gradio."""
+    
+    def reload_tools(url):
+        return playground.load_mcp_tools(url)
+        
+    def chat_response(message, history):
+        return playground.chat(message, history)
+        
+    return reload_tools, chat_response

src/mcp_server/server.py

@@ -0,0 +1,277 @@
+import gradio as gr
+import os
+import sys
+
+# Ajout du répertoire racine au path pour permettre les imports absolus 'src.xxx'
+sys.path.append(os.path.abspath(os.path.join(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
+
+# --- 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]
+        )
+        
+    # 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 ---
+
+@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(mcp_server=True)

src/mcp_server/tools.py

@@ -0,0 +1,165 @@
+from typing import Dict, Any
+
+from src.core.state.session_manager import SessionManager
+from src.core.builder.code_generator import CodeGenerator
+from src.core.deployer.huggingface import HFDeployer
+from src.core.builder.proposal_generator import proposal_generator
+
+# Initialisation des singletons
+session_manager = SessionManager()
+# Note: HFDeployer est instancié à la demande pour avoir le token le plus à jour ou géré par contexte si besoin
+# Pour l'instant on l'instancie à chaque déploiement.
+
+def init_project(project_name: str, description: str, type: str = "adhoc") -> Dict[str, Any]:
+    """
+    Crée un nouveau projet vide.
+    Args:
+        project_name: Nom technique (ex: strawberry-counter, ratp-api).
+        description: Description de l'outil, ou Spécification Technique complète (ex: contenu d'un Swagger/OpenAPI JSON).
+        type: 'adhoc' (code pur), 'api_wrapper' (REST).
+    Returns:
+        Un dictionnaire contenant le 'draft_id' nécessaire pour la suite.
+    """
+    draft = session_manager.create_draft(project_name, description, type)
+    return {
+        "draft_id": draft.draft_id,
+        "config": {
+            "name": draft.name,
+            "description": draft.description,
+            "files": list(draft.code_files.keys())
+        },
+        "message": f"Projet '{project_name}' initialisé. Draft ID: {draft.draft_id}"
+    }
+
+def propose_implementation(project_name: str, description: str) -> Dict[str, Any]:
+    """
+    Utilise l'IA interne pour proposer une implémentation complète à partir d'une description ou d'un Swagger.
+    Args:
+        project_name: Le nom du projet.
+        description: La description ou le JSON Swagger/OpenAPI.
+    Returns:
+        Un dictionnaire contenant le code Python proposé, les inputs détectés et les requirements.
+        L'agent appelant peut ensuite valider ou modifier ce code avant d'appeler define_logic.
+    """
+    try:
+        proposal = proposal_generator.generate_from_description(project_name, description)
+        return {
+            "status": "success",
+            "proposal": proposal,
+            "message": "Implémentation proposée. Veuillez réviser 'python_code' et 'requirements' avant d'appeler define_logic."
+        }
+    except Exception as e:
+        return {"error": f"Erreur lors de la génération: {str(e)}"}
+
+def define_logic(draft_id: str, python_code: str, inputs: Dict[str, str], output_desc: str, requirements: str = "") -> Dict[str, Any]:
+    """
+    Définit la logique interne de l'outil.
+    Génère à la fois le module modulaire et l'app maître.
+    """
+    draft = session_manager.get_draft(draft_id)
+    if not draft:
+        return {"error": f"Draft {draft_id} introuvable."}
+
+    # 1. Génération du module de l'outil (ex: tools/strawberry_counter.py)
+    # On utilise le nom du projet comme nom de fichier (nettoyé)
+    tool_filename = draft.name.replace("-", "_").lower()
+    tool_module_code = CodeGenerator.generate_tool_module(python_code, inputs, output_desc, draft.name)
+    
+    # 2. Génération de l'application maître (app.py)
+    master_app_code = CodeGenerator.generate_master_app()
+    
+    # Sauvegarde dans le draft
+    # On place l'outil dans un sous-dossier 'tools'
+    session_manager.update_code(draft_id, f"tools/{tool_filename}.py", tool_module_code)
+    session_manager.update_code(draft_id, "tools/__init__.py", "") # Package marker
+    session_manager.update_code(draft_id, "app.py", master_app_code)
+    
+    # Mise à jour des requirements
+    current_reqs = draft.code_files.get("requirements.txt", "")
+    new_reqs = current_reqs
+    
+    # Ajout de gradio si manquant
+    if "gradio" not in new_reqs:
+        new_reqs += "\ngradio"
+        
+    # Ajout des requirements spécifiques demandés par le LLM
+    if requirements:
+        # requirements peut être une liste ou une chaine (si via UI Textbox)
+        if isinstance(requirements, list):
+            req_list = requirements
+        else:
+            req_list = [r.strip() for r in requirements.split(",") if r.strip()]
+            
+        for req in req_list:
+            if req and req not in new_reqs:
+                new_reqs += f"\n{req}"
+    
+    draft.code_files["requirements.txt"] = new_reqs.strip()
+
+    return {
+        "status": "success",
+        "message": f"Logique générée pour '{draft.name}'. Prêt à déployer.",
+        "preview": tool_module_code[:200] + "..." 
+    }
+
+def deploy_to_space(draft_id: str, visibility: str = "public", space_target: str = "new", target_space_name: str = "") -> Dict[str, Any]:
+    """
+    Déploie le projet sur Hugging Face Spaces.
+    Args:
+        draft_id: ID du draft.
+        visibility: 'public' ou 'private'.
+        space_target: 'new' (créer une nouvelle toolbox) ou 'existing' (ajouter à une toolbox existante).
+        target_space_name: Nom forcé du space cible (optionnel pour 'new', obligatoire pour 'existing').
+    """
+    draft = session_manager.get_draft(draft_id)
+    if not draft:
+        return {"error": f"Draft {draft_id} introuvable."}
+
+    deployer = HFDeployer()
+    
+    # Détermination du nom du Space cible
+    # Si target_space_name est vide, on utilise le nom du projet
+    final_space_name = target_space_name if target_space_name else draft.name
+        
+    # Filtrage des fichiers à déployer
+    files_to_deploy = draft.code_files.copy()
+    
+    # Si on ajoute à un space existant, on n'écrase pas le loader principal (app.py)
+    if space_target == "existing":
+        if "app.py" in files_to_deploy:
+            del files_to_deploy["app.py"]
+        # On garde requirements.txt ? Idéalement il faudrait merger. 
+        # Pour simplifier, on l'enlève pour éviter d'écraser des déps existantes.
+        if "requirements.txt" in files_to_deploy:
+            del files_to_deploy["requirements.txt"]
+            
+    try:
+        url = deployer.deploy_space(
+            space_name=final_space_name,
+            files=files_to_deploy,
+            sdk="gradio",
+            private=(visibility == "private")
+        )
+        
+        mode_msg = "ajouté à la toolbox" if space_target == "existing" else "déployé (nouveau space)"
+        
+        # URL standard MCP pour Gradio (sans /sse explicite, compatible Claude Desktop)
+        mcp_endpoint = url.rstrip("/") + "/gradio_api/mcp/"
+        claude_config = f"""
+        {{
+          "mcpServers": {{
+            "{draft.name}": {{
+              "url": "{mcp_endpoint}"
+            }}
+          }}
+        }}
+        """
+        
+        return {
+            "status": "success",
+            "url": url,
+            "instructions": f"Outil '{draft.name}' {mode_msg} !",
+            "claude_config": claude_config
+        }
+    except Exception as e:
+        return {"error": f"Erreur de déploiement: {str(e)}"}

tests/test_deploy.py

@@ -0,0 +1,58 @@
+import os
+import sys
+from dotenv import load_dotenv
+
+# Ajout du dossier src au path pour pouvoir importer les modules
+sys.path.append(os.path.join(os.path.dirname(__file__), '..', 'src'))
+
+from core.deployer.huggingface import HFDeployer
+
+def test_deployment():
+    # Charger les variables d'environnement (pour HF_TOKEN)
+    load_dotenv()
+    
+    token = os.environ.get("HF_TOKEN")
+    if not token:
+        print("❌ Erreur: HF_TOKEN manquant dans les variables d'environnement.")
+        print("Veuillez créer un fichier .env avec HF_TOKEN=votre_token_write")
+        return
+
+    print("🧪 Démarrage du test de déploiement...")
+
+    deployer = HFDeployer(token=token)
+    
+    # Nom unique pour le test (avec timestamp pour éviter les conflits si possible, 
+    # mais pour simplifier on utilise un nom fixe 'test-meta-mcp-hello' que l'utilisateur pourra supprimer)
+    space_name = "test-meta-mcp-hello"
+    
+    # Code de l'application "Hello World"
+    app_code = """
+import gradio as gr
+
+def greet(name):
+    return "Hello " + name + " from Meta-MCP!"
+
+iface = gr.Interface(fn=greet, inputs="text", outputs="text")
+iface.launch()
+"""
+
+    files = {
+        "app.py": app_code,
+        "requirements.txt": "gradio"
+    }
+
+    try:
+        url = deployer.deploy_space(
+            space_name=space_name,
+            files=files,
+            sdk="gradio",
+            private=False
+        )
+        print(f"\n✅ Test réussi ! Space déployé sur : {url}")
+        print("⚠️ N'oubliez pas de supprimer ce Space manuellement si vous ne souhaitez pas le conserver.")
+        
+    except Exception as e:
+        print(f"\n❌ Échec du test : {str(e)}")
+
+if __name__ == "__main__":
+    test_deployment()