Version 1.94RC

.gitattributes

@@ -33,3 +33,6 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.jpeg filter=lfs diff=lfs merge=lfs -text
+*.jpg filter=lfs diff=lfs merge=lfs -text
+*.png filter=lfs diff=lfs merge=lfs -text

README.md

@@ -11,71 +11,70 @@ license: mit
 short_description: Create and deploy MCP servers using natural language.
 ---
 
-# 🏭 MCEPTION : La Méta-Factory de Serveurs MCP
+# 🏭 MCEPTION: Your MCP Servers agency
 
-**MCEPTION** est un serveur MCP (Model Context Protocol) propulsé par **Gradio** qui permet de générer, tester et déployer d'autres serveurs MCP à la volée. 
+**MCEPTION** is an MCP (Model Context Protocol) server powered by **Gradio** that allows generating, testing, and deploying other MCP servers on the fly.
 
-C'est un "Serveur MCP créateur de Serveurs MCP". Il permet à des agents IA (comme Claude, ChatGPT ou des agents autonomes `smolagents`) ou à des utilisateurs humains de créer de nouveaux serveurs MCP et outils ("Tools") associés personnalisés et de les déployer instantanément sur Hugging Face Spaces, étendant ainsi les capacités de leurs agents de manière récursive.
+It is an "MCP Server creator of MCP Servers". It enables AI agents (like Claude, ChatGPT, or autonomous `smolagents`) or human users to create new custom MCP servers and associated Tools, and deploy them instantly to Hugging Face Spaces, thus recursively extending their agent's capabilities.
 
-## 🌟 Pourquoi MCEPTION ?
+## 🌟 Why MCEPTION?
 
-Avec la généralisation des outils conversationnels et l'avènement annoncé de l'internet génératif, il devient essentiel pour les entreprises et les administrations de maîtriser les informations communiquées au public au travers de ces IA. 
+With the widespread adoption of conversational tools and the upcoming era of the generative internet, it becomes essential for companies and administrations to master the information communicated to the public through these AIs.
 
-Le protocole MCP combiné aux capacités de raisonnement des agents LLM offre aussi des possibilités quelques fois très difficiles à imaginer sans les implémenter et les tester. Il peut aussi parfois être décevant et nécessiter de nombreux réglages et ajustements. Si le protocole MCP est simple dans sa conception, il nécessite beaucoup de précaution pour qu'il fonctionne réellement bien. 
+The MCP protocol, combined with the reasoning capabilities of LLM agents, offers possibilities that are sometimes very difficult to imagine without implementing and testing them. It can also sometimes be disappointing and require numerous settings and adjustments. While the MCP protocol is simple in its design, it requires great care to work really well.
 
-MCEPTION répond à un besoin actuel, celui de fournir aux entreprises et aux administrations des outils, leur permettant de tester l'impact du protocole MCP pour leur activité. 
+MCEPTION answers a current need: providing organizations with tools to test the impact of the MCP protocol for their activity.
 
-Cet outil a ainsi été pensé de manière à profiter de la puissance de la structure agentique qui appelle le MCP (en général au travers de modèles top-tier), combiné aux LLM spécifiques tels que GPT OSS ou Kimi K2 thinking pour un codage réactif en phase de conception des outils.
+This tool has been designed to leverage the power of the agentic structure calling the MCP (generally through top-tier models), combined with specific LLMs such as GPT OSS or Kimi K2 thinking for reactive coding during the tool design phase.
 
-Avec MCEPTION, les organisations peuvent directement essayer le MCP en essayant, par exemple, d'encapsuler des API existantes ou de créer des serveurs autour de fichiers de données, voir d'exposer des règles de gestion directement codées et permettant aux agents de répondre de façon déterministe et maîtrisée sur les sujets qui les concernent.
+With MCEPTION, organizations can directly try MCP by attempting, for example, to encapsulate existing APIs, create servers around data files, or even expose directly coded business rules allowing agents to answer deterministically and in a controlled manner on subjects that concern them.
 
-## Un workflow intuitif pour les humains et pour les IA
+## An Intuitive Workflow for Humans and AIs
 
-L'outil a été conçu de manière à offrir un workflow de création intuitif que ce soit pour les humains ou pour les agents d'intelligence artificielle. Il permet notamment de tester directement au travers d'une instance smolagents le fonctionnement du serveur généré, de voir les outils s'afficher et de les essayer.
+The tool has been designed to offer an intuitive creation workflow whether for humans or for artificial intelligence agents. In particular, it allows direct testing through a smolagents instance of the generated server's operation, seeing the tools appear and trying them out.
 
-L'environnement idéal pour tester les serveurs MCP générés restent [Hugging Chat](https://huggingface.co/chat/) pour les modèles Open source grâce au reload à chaud des serveurs MCP et de leurs outils.
+The ideal environment for testing generated MCP servers remains [Hugging Chat](https://huggingface.co/chat/) for Open Source models thanks to the hot reload of MCP servers and their tools.
 
-Côt�� outils propriétaires, le client local Claude fonctionne très bien et pour intégrer les les outils d'Claude sont fournis par l'application.
+On the proprietary tools side, the local Claude client works very well, and configurations to integrate tools into Claude are provided by the application.
 
-## Merci Gradio
+## Thanks Gradio
 
-Ce projet illustre les capacités impressionnantes de Gradio à exposer des services MCP, il s'articule parfaitement avec l'infrastructure Spaces de Hugging Face, qui est très bien complété aujourd'hui par les services d'inférence, au travers de l'API d'inférence et de Hugging Chat.
+This project illustrates the impressive capabilities of Gradio to expose MCP services; it articulates perfectly with the Hugging Face Spaces infrastructure, which is very well complemented today by inference services, through the Inference API and Hugging Chat.
 
+## 🚀 Key Features
 
-## 🚀 Fonctionnalités Clés
-
-*   **Initialisation en Langage Naturel** : Décrivez simplement l'outil : *"Je veux un outil qui me donne la météo de Paris"* ou *"Crée un convertisseur de devises"*.
-*   **Génération de Code Intelligente** : Utilise des LLMs performants (GPT OSS, Kimi K2 Thinking) via les providers d'inférence routés par HuggingFace (Together AI, Hyperbolic) pour écrire le code Python.
-*   **Sandbox & Validation** : Vérifiez et modifiez le code proposé avant le déploiement.
-*   **Déploiement Automatisé sur HF Spaces** : En un clic (ou un appel d'outil), votre serveur MCP est en ligne, hébergé gratuitement sur Hugging Face Spaces.
-*   **Compatible MCP Natif** : Les outils générés sont immédiatement utilisables via le protocole MCP exposé nativement par Gradio 6.
+*   **Natural Language Initialization**: Simply describe the tool: *"I want a tool that gives me the weather in Paris"* or *"Create a currency converter"*.
+*   **Intelligent Code Generation**: Uses powerful LLMs (GPT OSS, Kimi K2 Thinking) via inference providers routed by HuggingFace (Together AI, Hyperbolic) to write Python code.
+*   **Sandbox & Validation**: Check and modify the proposed code before deployment.
+*   **Automated Deployment on HF Spaces**: In one click (or tool call), your MCP server is online, hosted for free on Hugging Face Spaces.
+*   **Native MCP Compatible**: Generated tools are immediately usable via the MCP protocol natively exposed by Gradio 6.
 
 ## 🛠️ Architecture
 
 
 
-## 📚 Installation & Démarrage
+## 📚 Installation & Getting Started
 
-### 1. Déploiement Rapide sur Hugging Face Spaces
+### 1. Quick Deployment on Hugging Face Spaces
 
-C'est la méthode recommandée pour utiliser MCEPTION sans installation locale.
+This is the recommended method to use MCEPTION without local installation.
 
-1.  **Dupliquer le Space** :
-    *   Cliquez sur le menu (trois points) en haut à droite de cette page, puis sur **"Duplicate this Space"**.
-    *   Choisissez un nom pour votre Space et validez.
+1.  **Duplicate the Space**:
+    *   Click on the menu (three dots) at the top right of this page, then on **"Duplicate this Space"**.
+    *   Choose a name for your Space and validate.
 
-2.  **Configuration du Token (Indispensable)** :
-    *   Une fois le Space dupliqué, allez dans l'onglet **Settings** de votre nouveau Space.
-    *   Descendez à la section **Variables and secrets**.
-    *   Cliquez sur **New secret**.
-    *   **Name** : `HF_TOKEN`
-    *   **Value** : Votre token Hugging Face (assurez-vous qu'il a les permissions **WRITE**). Vous pouvez en créer un ici : [https://huggingface.co/settings/tokens](https://huggingface.co/settings/tokens).
+2.  **Token Configuration (Essential)**:
+    *   Once the Space is duplicated, go to the **Settings** tab of your new Space.
+    *   Scroll down to the **Variables and secrets** section.
+    *   Click on **New secret**.
+    *   **Name**: `HF_TOKEN`
+    *   **Value**: Your Hugging Face token (make sure it has **WRITE** permissions). You can create one here: [https://huggingface.co/settings/tokens](https://huggingface.co/settings/tokens).
     
-    *Le Space redémarrera automatiquement avec vos droits, prêt à créer de nouveaux Spaces pour vous !*
+    *The Space will restart automatically with your rights, ready to create new Spaces for you!*
 
-### 2. Utilisation avec Claude Desktop
+### 2. Usage with Claude Desktop
 
-Pour transformer votre Claude Desktop en "usine à outils", ajoutez la configuration suivante à votre fichier `claude_desktop_config.json` :
+To turn your Claude Desktop into a "tool factory", add the following configuration to your `claude_desktop_config.json` file:
 
 ```json
 {
@@ -92,44 +91,44 @@ Pour transformer votre Claude Desktop en "usine à outils", ajoutez la configura
 }
 ```
 
-> **Note** : Si vous utilisez MCEPTION depuis un Space Hugging Face public, remplacez l'URL locale par l'URL de votre Space (ex: `https://alihmaou-metamcp-proto.hf.space/gradio_api/mcp/sse`).
+> **Note**: If you are using MCEPTION from a public Hugging Face Space, replace the local URL with your Space URL (e.g. `https://alihmaou-metamcp-proto.hf.space/gradio_api/mcp/sse`).
 
-## 🤖 Guide pour les Agents (API)
+## 🤖 Guide for Agents (API)
 
-MCEPTION expose une suite d'outils MCP permettant à un agent autonome de gérer tout le cycle de vie de création d'outil.
+MCEPTION exposes a suite of MCP tools allowing an autonomous agent to manage the entire tool creation lifecycle.
 
-### Workflow Typique
+### Typical Workflow
 
-1.  **Configuration** (Optionnel) : `step_0_configuration` pour définir le user HF ou le token si non présent dans l'environnement.
-2.  **Conception** : `expert_step1_propose_implementation` ou `step_1_initialisation_and_proposal`. L'agent soumet une description, le serveur renvoie un `draft_id` et une proposition de code.
-3.  **Validation** : `expert_step2_define_logic`. L'agent confirme le code et les dépendances.
-4.  **Déploiement** : `step_3_deployment`. Le serveur crée le Space Hugging Face.
-5.  **Utilisation** : L'agent reçoit la config pour se connecter à ce nouveau serveur.
+1.  **Configuration** (Optional): `step_0_configuration` to set the HF user or token if not present in the environment.
+2.  **Design**: `expert_step1_propose_implementation` or `step_1_initialisation_and_proposal`. The agent submits a description, the server returns a `draft_id` and a code proposal.
+3.  **Validation**: `expert_step2_define_logic`. The agent confirms the code and dependencies.
+4.  **Deployment**: `step_3_deployment`. The server creates the Hugging Face Space.
+5.  **Usage**: The agent receives the config to connect to this new server.
 
-### Liste des Outils Exposés
+### List of Exposed Tools
 
-| Outil | Description |
+| Tool | Description |
 | :--- | :--- |
-| `step_0_configuration` | Configure l'environnement (User HF, Token, Default Space). |
-| `step_1_initialisation_and_proposal` | (UI+API) Initialise un projet et propose une implémentation via LLM. |
-| `step_2_logic_definition` | (UI+API) Valide et enregistre le code Python de l'outil. |
-| `step_3_deployment` | (UI+API) Déploie l'outil sur un Space Hugging Face. |
-| `expert_step1_propose_implementation` | (API Expert) Génère juste le code sans état UI (utile pour itérer). |
-| `expert_step2_define_logic` | (API Expert) Définit la logique avec des entrées JSON complexes. |
-| `util_delete_tool` | Supprime un outil d'un Space existant. |
-| `util_get_tool_code` | Récupère le code source d'un outil existant pour inspection. |
+| `step_0_configuration` | Configures the environment (HF User, Token, Default Space). |
+| `step_1_initialisation_and_proposal` | (UI+API) Initializes a project and proposes an implementation via LLM. |
+| `step_2_logic_definition` | (UI+API) Validates and saves the tool's Python code. |
+| `step_3_deployment` | (UI+API) Deploys the tool to a Hugging Face Space. |
+| `expert_step1_propose_implementation` | (Expert API) Generates just the code without UI state (useful for iterating). |
+| `expert_step2_define_logic` | (Expert API) Defines logic with complex JSON inputs. |
+| `util_delete_tool` | Deletes a tool from an existing Space. |
+| `util_get_tool_code` | Retrieves the source code of an existing tool for inspection. |
 
-## 💡 Exemple de Prompt pour Claude
+## 💡 Example Prompt for Claude
 
-Une fois MCEPTION connecté à Claude, vous pouvez lui dire :
+Once MCEPTION is connected to Claude, you can tell it:
 
-> "Crée-moi un outil qui permet de récupérer le prix actuel du Bitcoin en utilisant l'API CoinGecko, et déploie-le sur mon espace Hugging Face."
+> "Create me a tool that retrieves the current Bitcoin price using the CoinGecko API, and deploy it to my Hugging Face space."
 
-Claude va alors :
-1.  Appeler `step_1` pour générer le code Python (`requests.get(...)`).
-2.  Vous demander confirmation ou appeler `step_2` pour valider.
-3.  Appeler `step_3` pour déployer.
-4.  Vous donner la config pour utiliser ce nouvel outil "Bitcoin Price" immédiatement !
+Claude will then:
+1.  Call `step_1` to generate the Python code (`requests.get(...)`).
+2.  Ask you for confirmation or call `step_2` to validate.
+3.  Call `step_3` to deploy.
+4.  Give you the config to use this new "Bitcoin Price" tool immediately!
 
 ---
-*Fait avec ❤️, Python, Gradio et beaucoup d'Agents.*
+*Made with ❤️, Python, Gradio and a lot of Agents.*

app.py

@@ -16,4 +16,5 @@ if __name__ == "__main__":
     # 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)
+    # allowed_paths=["assets"] permet de servir les fichiers statiques du dossier assets
+    demo.launch(server_name="0.0.0.0", server_port=7860, mcp_server=True, show_error=True, allowed_paths=["assets"])

src/core/builder/code_generator.py

@@ -4,28 +4,28 @@ 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.
+        Generates the complete code for a Gradio application from a function snippet.
         
         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
+            function_code: The source code of the main function (e.g. def count_r(word): ...)
+            inputs: Dict describing inputs (e.g. {"word": "text"})
+            output_desc: Description of the output
             
         Returns:
-            Le code source complet de app.py
+            The complete source code for 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("
+        # Simple analysis to find the function name (very naive for now)
+        # We assume the code contains "def function_name("
         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
+        # Mapping MCP/JSON types to Gradio types
+        # For simplicity, we map everything to Text for now or use direct strings
+        # TODO: Improve type mapping
         
-        # Construction du code
+        # Code construction
         template = f"""
 import gradio as gr
 import json
@@ -35,14 +35,14 @@ import json
 
 # --- Gradio Interface ---
 
-# Wrapper pour gérer les types si nécessaire
+# Wrapper to handle types if necessary
 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.
+# Gradio inputs configuration
+# Note: This part is generic for the MVP.
+# Ideally, iterate over 'inputs' to create corresponding Gradio components.
 
 iface = gr.Interface(
     fn=wrapper,
@@ -60,7 +60,7 @@ if __name__ == "__main__":
     @staticmethod
     def generate_tool_module(function_code: str, inputs: dict, output_desc: str, tool_name: str, output_component: str = "text") -> str:
         """
-        Génère un module Python contenant la logique de l'outil et une factory d'interface.
+        Generates a Python module containing the tool logic and an interface factory.
         """
         import re
         match = re.search(r"def\s+([a-zA-Z_][a-zA-Z0-9_]*)\s*\(", function_code)
@@ -68,7 +68,7 @@ if __name__ == "__main__":
         
         inputs_keys_str = str(list(inputs.keys()))
 
-        # Mapping du composant de sortie
+        # Output component mapping
         if output_component == "image":
             gradio_output = 'gr.Image(type="filepath", label="__OUTPUT_DESC__")'
         elif output_component == "audio":
@@ -107,7 +107,7 @@ def create_interface():
         code = code.replace("__FUNCTION_CODE__", function_code)
         code = code.replace("__FUNC_NAME__", func_name)
         code = code.replace("__INPUTS_KEYS__", inputs_keys_str)
-        code = code.replace("__GRADIO_OUTPUT__", gradio_output) # Injection du composant dynamique
+        code = code.replace("__GRADIO_OUTPUT__", gradio_output) # Dynamic component injection
         code = code.replace("__OUTPUT_DESC__", output_desc)
         code = code.replace("__TOOL_NAME__", tool_name)
         
@@ -116,8 +116,8 @@ def create_interface():
     @staticmethod
     def generate_master_app() -> str:
         """
-        Génère le fichier app.py principal.
-        Utilise une approche standard avec import dynamique simple.
+        Generates the main app.py file.
+        Uses a standard approach with simple dynamic import.
         """
         template = """
 import gradio as gr
@@ -128,13 +128,13 @@ import importlib
 # Configuration
 TOOLS_DIR = "tools"
 
-# S'assurer que le dossier tools existe et est un package
+# Ensure tools directory exists and is a 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
+# Add current directory to path so 'import tools.xxx' works
 sys.path.append(os.path.dirname(os.path.abspath(__file__)))
 
 interfaces = []
@@ -143,7 +143,7 @@ names = []
 print(f"🚀 Starting Meta-MCP Toolbox...")
 print(f"📂 Scanning '{TOOLS_DIR}' directory...")
 
-# Scan et import des outils
+# Scan and import tools
 try:
     for filename in sorted(os.listdir(TOOLS_DIR)):
         if filename.endswith(".py") and not filename.startswith("_"):
@@ -152,13 +152,13 @@ try:
             
             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
+                # Standard dynamic import
+                # Use reload to ensure latest version is taken if restarted
                 module = importlib.import_module(full_module_name)
                 importlib.reload(module)
                 
                 if hasattr(module, "create_interface"):
-                    # Création de l'interface Gradio pour cet outil
+                    # Create Gradio interface for this tool
                     tool_interface = module.create_interface()
                     interfaces.append(tool_interface)
                     names.append(module_name)
@@ -173,7 +173,7 @@ try:
 except Exception as e:
     print(f"Error scanning tools directory: {e}")
 
-# Construction de l'interface finale
+# Final interface construction
 if not interfaces:
     demo = gr.Interface(
         fn=lambda x: "No tools loaded yet. Add a tool via Meta-MCP!", 
@@ -193,6 +193,6 @@ if __name__ == "__main__":
     @staticmethod
     def generate_mcp_server_code(function_code: str) -> str:
         """
-        Génère un serveur MCP (FastMCP) au lieu de Gradio (Future feature).
+        Generates an MCP server (FastMCP) instead of Gradio (Future feature).
         """
         pass

src/core/builder/proposal_generator.py

@@ -10,18 +10,18 @@ class ProposalGenerator:
 
     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é.
+        Generates a code and configuration proposal from a description.
+        Uses chat_completion for better compatibility.
         """
         
-        # 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.
+        # Dynamic client configuration if necessary (e.g. provider change)
+        # Note: InferenceClient is lightweight, we can instantiate it on demand or use the existing one
+        # If provider is specified, use it. Otherwise let HF choose.
         # "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}")
+        print(f"🤖 LLM Call with Model: {model}, Provider: {provider}")
         
         # Use current environment variable if available (supports UI updates), otherwise fallback to init token
         current_token = os.environ.get("HF_TOKEN", self.token)
@@ -72,18 +72,18 @@ Do not use markdown formatting (no ```json). Just the raw JSON string.
                 stream=False
             )
             
-            # Extraction du contenu
+            # Content extraction
             content = response.choices[0].message.content.strip()
             
-            # Extraction robuste du JSON via Regex
+            # Robust JSON extraction via Regex
             import re
-            # Cherche le premier { et le dernier }
+            # Finds the first { and the last }
             match = re.search(r'\{.*\}', content, re.DOTALL)
             if match:
                 json_content = match.group(0)
                 return json.loads(json_content)
             
-            # Fallback : tentative de parsing direct si regex échoue (ex: liste ou autre format)
+            # Fallback: direct parsing attempt if regex fails (e.g. list or other format)
             return json.loads(content)
             
         except Exception as e:

src/core/deployer/huggingface.py

@@ -5,18 +5,18 @@ 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.
+        Initializes the Hugging Face deployer.
+        If token is None, tries to retrieve it from HF_TOKEN environment variable
+        or local cache.
         """
         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.")
+            raise ValueError("No Hugging Face token found. Please set 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."""
+        """Sanitizes the repo/space name to handle URLs and partial formats."""
         input_name = input_name.strip()
         
         # Cas URL complète : https://huggingface.co/spaces/user/repo
@@ -44,30 +44,30 @@ class HFDeployer:
                      sdk: str = "gradio", 
                      private: bool = False) -> str:
         """
-        Crée un Space et déploie les fichiers.
+        Creates a Space and deploys files.
         
         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é
+            space_name: Space name (e.g. 'strawberry-counter')
+            files: Dictionary {filename: content} (e.g. {'app.py': '...'})
+            username: Target username or organization. If None, uses current user.
+            sdk: 'gradio', 'streamlit', or 'docker'
+            private: If True, creates a private repo
             
         Returns:
-            L'URL du Space déployé.
+            The deployed Space URL.
         """
         
-        # 1. Déterminer le repo_id complet
+        # 1. Determine full repo_id
         if not username:
             user_info = self.api.whoami()
             username = user_info["name"]
         
-        # Utilisation de la méthode de nettoyage
+        # Use sanitization method
         repo_id = self._sanitize_repo_id(space_name, username)
         
-        print(f"🚀 Préparation du déploiement vers {repo_id}...")
+        print(f"🚀 Preparing deployment to {repo_id}...")
 
-        # 2. Création du repo (idempotent: ne plante pas s'il existe déjà)
+        # 2. Repo creation (idempotent: does not crash if already exists)
         try:
             self.api.create_repo(
                 repo_id=repo_id,
@@ -76,14 +76,14 @@ class HFDeployer:
                 private=private,
                 exist_ok=True
             )
-            print(f"✅ Repo {repo_id} prêt.")
+            print(f"✅ Repo {repo_id} ready.")
         except Exception as e:
-            raise RuntimeError(f"Erreur lors de la création du repo: {str(e)}")
+            raise RuntimeError(f"Error creating repo: {str(e)}")
 
-        # 3. Upload des fichiers
+        # 3. File upload
         operations = []
         for filename, content in files.items():
-            # On encode le contenu en bytes pour l'upload
+            # Encode content to bytes for upload
             content_bytes = content.encode("utf-8")
             operations.append(
                 self.api.run_as_future(
@@ -101,7 +101,7 @@ class HFDeployer:
         
         try:
             for filename, content in files.items():
-                print(f"📤 Upload de {filename}...")
+                print(f"📤 Uploading {filename}...")
                 content_bytes = content.encode("utf-8")
                 self.api.upload_file(
                     path_or_fileobj=content_bytes,
@@ -110,13 +110,13 @@ class HFDeployer:
                     repo_type="space",
                     commit_message=f"Deploy {filename} via Meta-MCP"
                 )
-            print("✅ Tous les fichiers ont été uploadés.")
+            print("✅ All files uploaded.")
         except Exception as e:
-             raise RuntimeError(f"Erreur lors de l'upload des fichiers: {str(e)}")
+             raise RuntimeError(f"Error uploading files: {str(e)}")
 
-        # 4. Construction de l'URL
-        # L'URL standard est https://huggingface.co/spaces/USERNAME/SPACE_NAME
+        # 4. URL Construction
+        # Standard URL is 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}")
+        print(f"🎉 Deployment finished! Space accessible here: {space_url}")
         return space_url

src/core/state/session_manager.py

@@ -18,7 +18,7 @@ class SessionManager:
         self._drafts: Dict[str, ProjectDraft] = {}
 
     def create_draft(self, name: str, description: str, type: str = "adhoc") -> ProjectDraft:
-        """Crée un nouveau brouillon de projet."""
+        """Creates a new project draft."""
         draft_id = str(uuid.uuid4())
         draft = ProjectDraft(
             draft_id=draft_id,
@@ -33,11 +33,11 @@ class SessionManager:
         return draft
 
     def get_draft(self, draft_id: str) -> Optional[ProjectDraft]:
-        """Récupère un brouillon par son ID."""
+        """Retrieves a draft by its 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."""
+        """Updates a code file in the draft."""
         draft = self.get_draft(draft_id)
         if not draft:
             return False
@@ -45,5 +45,5 @@ class SessionManager:
         return True
 
     def list_drafts(self) -> Dict[str, str]:
-        """Liste tous les brouillons actifs."""
+        """Lists all active drafts."""
         return {d.draft_id: d.name for d in self._drafts.values()}

src/mcp_server/playground.py

@@ -8,18 +8,18 @@ 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."""
+    """Removes ANSI escape codes (colors) from text."""
     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.
+# Note: MCPClient might not be directly exposed by smolagents in all versions.
+# If import fails, a different approach or version check might be needed.
+# User provided `from smolagents import ..., MCPClient`, so we follow this path.
 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
+    # Fallback or mock if MCPClient is not yet in the installed version
+    # Assuming it's good as requested by user for now
     MCPClient = None 
 
 class PlaygroundManager:
@@ -29,29 +29,29 @@ class PlaygroundManager:
         self.mcp_client = None
 
     def load_mcp_tools(self, mcp_url: str):
-        """Connecte le client MCP à l'URL donnée et charge les outils."""
+        """Connects the MCP client to the given URL and loads tools."""
         try:
-            # Nettoyage de l'ancien client
+            # Cleanup old client
             if self.mcp_client:
-                # self.mcp_client.disconnect() # Si méthode existe
+                # self.mcp_client.disconnect() # If method exists
                 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
+            # Initialize MCP Client
+            # User requested to ignore SSE mode and use streamable HTTP
+            # Clean URL if it still contains /sse by mistake
             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
+            # Pass URL without forcing SSE transport, smolagents should handle it
+            # Note: Pass URL directly if possible, or in a dict depending on API
+            # structured_output=False to avoid FutureWarning and stay compatible
             self.mcp_client = MCPClient({"url": mcp_url}, structured_output=False) 
             
-            # Récupération des outils
+            # Retrieve tools
             self.tools = self.mcp_client.get_tools()
             
-            # Configuration de l'agent
-            # On utilise HF_TOKEN pour le modèle d'inférence
+            # Agent Configuration
+            # Use HF_TOKEN for inference model
             token = os.environ.get("HF_TOKEN")
             if not token:
                 return pd.DataFrame({"Error": ["HF_TOKEN env var is missing"]}), "Error: HF_TOKEN missing"
@@ -59,10 +59,10 @@ class PlaygroundManager:
             model = InferenceClientModel(token=token)
             self.agent = CodeAgent(tools=self.tools, model=model)
             
-            # Création du DataFrame pour l'affichage
+            # Create DataFrame for display
             rows = []
             for tool in self.tools:
-                # Gestion simplifiée des inputs pour l'affichage
+                # Simplified input handling for display
                 input_desc = str(tool.inputs) if hasattr(tool, 'inputs') else "N/A"
                 rows.append({
                     "Tool name": tool.name,
@@ -71,33 +71,33 @@ class PlaygroundManager:
                 })
             
             df = pd.DataFrame(rows)
-            return df, f"Succès ! {len(self.tools)} outils chargés depuis {mcp_url}"
+            return df, f"Success! {len(self.tools)} tools loaded from {mcp_url}"
 
         except Exception as e:
             import traceback
             traceback.print_exc()
-            return pd.DataFrame({"Error": [str(e)]}), f"Erreur de connexion: {str(e)}"
+            return pd.DataFrame({"Error": [str(e)]}), f"Connection error: {str(e)}"
 
     def chat(self, message: str, history: list):
-        """Exécute le message utilisateur via l'agent en capturant la réflexion."""
+        """Executes user message via agent capturing reflection."""
         if not self.agent:
-            return "⚠️ Veuillez d'abord charger un serveur MCP valide."
+            return "⚠️ Please load a valid MCP server first."
         
-        # Capture de la sortie standard (logs de réflexion de smolagents)
+        # Capture stdout (smolagents reflection logs)
         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
+                # Run smolagents agent
+                # Note: Real streaming of reflection would require deeper integration with smolagents
                 response = self.agent.run(message)
             
-            # Nettoyage des logs (suppression des couleurs ANSI qui cassent le Markdown)
+            # Clean logs (remove ANSI colors that break 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
+            # Format response with cleaned reflection logs
             if clean_logs:
-                formatted_response = f"**💭 Réflexion de l'agent :**\n```text\n{clean_logs}\n```\n\n**✅ Réponse :**\n{str(response)}"
+                formatted_response = f"**💭 Agent Reflection:**\n```text\n{clean_logs}\n```\n\n**✅ Response:**\n{str(response)}"
             else:
                 formatted_response = str(response)
                 
@@ -106,14 +106,14 @@ class PlaygroundManager:
         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}"
+            return f"Error executing agent: {str(e)}\n\nPartial logs:\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
+# Singleton to manage playground state in Gradio instance
+# Warning: In a real multi-user deployment, state should be managed by gr.State
 playground = PlaygroundManager()
 
 def get_playground_ui_handlers():
-    """Retourne les fonctions wrappers pour l'UI Gradio."""
+    """Returns wrapper functions for Gradio UI."""
     
     def reload_tools(url):
         return playground.load_mcp_tools(url)

src/mcp_server/server.py

@@ -47,12 +47,12 @@ def step_1_initialisation_and_proposal(project_name, description, model_id, prov
     init_result = tools.init_project(project_name, description, type="adhoc")
     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})...")
+    # 2. AI Proposal Generation
+    gr.Info("AI code generation in progress...")
+    print(f"🤖 Generating proposal for: {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.")
+    gr.Info("Proposal generated! Please validate in the next tab.")
     
     # 3. Retourne les données pour mettre à jour l'UI
     # Gère le cas où 'requirements' n'est pas renvoyé par le LLM
@@ -97,9 +97,9 @@ def step_2_logic_definition(draft_id: str, python_code: str, inputs: Any, output
     result = tools.define_logic(draft_id, python_code, inputs, output_desc, requirements, output_component)
     
     if "error" not in result:
-        gr.Info("Code validé et enregistré ! Prêt à déployer.")
+        gr.Info("Code validated and saved! Ready to deploy.")
     else:
-        gr.Info(f"Erreur : {result['error']}")
+        gr.Info(f"Error: {result['error']}")
         
     return result
 
@@ -112,8 +112,8 @@ 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
+    gr.Info("Deployment in progress... This may take a few minutes.")
+    # Simplification: Always public, always new (overwrite/create), space name = project name
     result = tools.deploy_to_space(draft_id, visibility="public", space_target="new", target_space_name=None)
     
     status_msg = ""
@@ -123,9 +123,9 @@ def step_3_deployment(draft_id):
     
     if "error" not in result:
         space_url_val = result.get('url', '')
-        gr.Info(f"Déploiement réussi ! URL : {space_url_val}")
+        gr.Info(f"Deployment successful! URL: {space_url_val}")
         
-        status_msg = "### 🚀 Déploiement réussi !"
+        status_msg = "### 🚀 Deployment successful!"
         
         # Construction de l'URL MCP
         mcp_url_val = space_url_val
@@ -169,8 +169,8 @@ def step_3_deployment(draft_id):
         )
 
     else:
-        gr.Info(f"Échec du déploiement : {result.get('error')}")
-        status_msg = f"### ❌ Échec du déploiement\n\nErreur : {result.get('error')}"
+        gr.Info(f"Deployment failed: {result.get('error')}")
+        status_msg = f"### ❌ Deployment failed\n\nError: {result.get('error')}"
     
     # Retourne : 
     # 1. JSON result (pour out_deploy)
@@ -188,7 +188,7 @@ reload_tools_handler, chat_response_handler = get_playground_ui_handlers()
 
 def step_0_configuration(hf_user: str = None, hf_token: str = None, default_space: str = None):
     """
-    STEP 0: Configures the Meta-MCP server environment.
+    STEP 0: Configures the MCEPTION server environment.
     
     This step is needed to set up the Hugging Face environment.
     
@@ -276,23 +276,29 @@ def util_get_tool_code(space_name: str, tool_name: str):
 # --- Construction de l'interface ---
 
 with gr.Blocks(title="MCePtion") as demo:
-    gr.Markdown("# 🏭 MCePtion is the MCP of your MCPs")
-    gr.Markdown("Ce serveur permet de créer et déployer d'autres serveurs MCP sur Hugging Face Spaces.")
+    # Bandeau haut (Image croppée à 50% de hauteur)
+    gr.HTML("""
+    <div style="width: 100%; overflow: hidden; margin-bottom: 20px;">
+        <img src="/file=assets/images/header_bg.jpeg" style="width: 100%; display: block; border-radius: 8px;" alt="MCePtion Header">
+    </div>
+    """)
+    gr.Markdown("# 🏭 MCEPTION is the MCP of your MCPs")
+    gr.Markdown("This server allows you to create and deploy other MCP servers on Hugging Face Spaces.")
 
     with gr.Tab("0. Setup & How-to"):
-        gr.Markdown("## Configuration Globale")
+        gr.Markdown("## Global Configuration")
         with gr.Row():
             hf_user_profile = gr.Textbox(
                 label="HF User Profile / Namespace", 
                 value=os.environ.get("HF_USER", ""),
-                placeholder="ex: alihmaou",
-                info="Votre nom d'utilisateur ou organisation Hugging Face par défaut."
+                placeholder="e.g. alihmaou",
+                info="Your default Hugging Face username or organization."
             )
             default_mcp_space_name = gr.Textbox(
                 label="Default Toolbox Name",
                 value=os.environ.get("DEFAULT_SPACE", "mymcpserver"),
-                placeholder="ex: mymcpserver",
-                info="Nom du Space (Toolbox) par défaut pour les ajouts (sera concaténé avec le user)."
+                placeholder="e.g. mymcpserver",
+                info="Default Space (Toolbox) name for additions (will be concatenated with user)."
             )
         
         with gr.Row():
@@ -300,46 +306,46 @@ with gr.Blocks(title="MCePtion") as demo:
                 label="HF Write Token (Optional override)",
                 type="password",
                 placeholder="hf_...",
-                info="Token pour le déploiement. Si vide, utilise la variable d'environnement HF_TOKEN du serveur."
+                info="Deployment token. If empty, uses the server's HF_TOKEN environment variable."
             )
             
-        # Bouton pour appliquer la config (simple mise à jour des variables globales/env pour la session)
+        # Button to apply config (simple update of global variables/env for the session)
         btn_save_config = gr.Button("Save Configuration")
         
         def save_config_ui(user: str, space: str, token: str):
             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 !")
+            gr.Info("Configuration saved!")
             return f"Configuration saved! User: {user}, Default Space: {space}"
             
         config_status = gr.Markdown("")
         btn_save_config.click(save_config_ui, inputs=[hf_user_profile, default_mcp_space_name, hf_token_input], outputs=config_status)
             
-        gr.Markdown("## Comment utiliser ce serveur MCePtion ?")
+        gr.Markdown("## How to use this MCePtion server?")
         
         with gr.Row():
-            with gr.Column("Guide Utilisateur"):
+            with gr.Column("User Guide"):
                 gr.Markdown("""
-                ## Guide d'utilisation de l'interface humaine
+                ## Human Interface User Guide
                 
-                ### 1. Création d'un Outil
-                *   Allez dans l'onglet **1. Initialisation**.
-                *   Donnez un nom et décrivez ce que vous voulez (ou collez un Swagger).
-                *   Cliquez sur "Initialiser & Générer".
+                ### 1. Tool Creation
+                *   Go to tab **1. Initialization**.
+                *   Provide a name and describe what you want (or paste a Swagger).
+                *   Click on "Initialize & Generate".
                 
-                ### 2. Validation du Code
-                *   Allez dans l'onglet **2. Précision de la logique**.
-                *   Vérifiez le code Python généré et les dépendances.
-                *   Cliquez sur "Générer le code" pour valider.
+                ### 2. Code Validation
+                *   Go to tab **2. Logic Definition**.
+                *   Check the generated Python code and dependencies.
+                *   Click on "Validate Code" to validate.
                 
-                ### 3. Déploiement
-                *   Allez dans l'onglet **3. Déploiement**.
-                *   Choisissez "New" pour créer un nouveau Space ou "Existing" pour ajouter à une Toolbox.
-                *   Cliquez sur "Déployer".
+                ### 3. Deployment
+                *   Go to tab **3. Deployment**.
+                *   Choose "New" to create a new Space or "Existing" to add to a Toolbox.
+                *   Click on "Deploy".
                 
                 ### 4. Test
-                *   Utilisez l'onglet **4. Playground** pour tester votre nouvel outil après son initialisation (environ 1 minute).
+                *   Use the **4. Playground** tab to test your new tool after initialization (approx. 1 minute).
                 """)
             
             with gr.Column():
@@ -370,63 +376,63 @@ with gr.Blocks(title="MCePtion") as demo:
                     }
                 }
                 _c_claude_config_str = json.dumps(_c_claude_config, indent=2)
-                gr.Markdown("""## Paramètres d'intégration MCP""")
+                gr.Markdown("""## MCP Integration Settings""")
                 gr.Code(label="URL of this space :", value=_c_space_url, language=None, interactive=False, lines=1)
                 gr.Code(label="URL of MCP endpoint :", value=_c_mcp_url, language=None, interactive=False, lines=1)
                 gr.Code(label="Claude Desktop Configuration", value=_c_claude_config_str, language="json", interactive=False)
 
             
 
-    with gr.Tab("1. Initialisation"):
-        gr.Markdown("Commencez par initialiser un nouveau projet.")
+    with gr.Tab("1. Initialization"):
+        gr.Markdown("Start by initializing a new project.")
         
-        project_name = gr.Textbox(label="ex: Nom du projet (ex: strawberry-counter, city-weather)...")
+        project_name = gr.Textbox(label="e.g. Project Name (e.g. strawberry-counter, city-weather)...")
         
         project_desc = gr.Textbox(
-            label="Description de l'outil ou Spécification (Swagger/OpenAPI JSON)",
+            label="Tool Description or Specification (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."
+            placeholder="Describe what the tool should do, or paste the content of a swagger.json file here to generate an API client automatically."
         )
         
-        with gr.Accordion("Paramètres IA (Avancé)", open=False):
+        with gr.Accordion("AI Settings (Advanced)", open=False):
             provider_id = gr.Dropdown(
-                label="Provider d'Inférence", 
+                label="Inference Provider", 
                 choices=["sambanova", "together", "None", "hyperbolic", "fal-ai", "replicate", "novita", "nebius", "cerebras", "fireworks", "groq"], 
                 value="together",
-                info="Sélectionnez un provider spécifique."
+                info="Select a specific provider."
             )
             
             model_id = gr.Dropdown(
-                label="Modèle LLM", 
+                label="LLM Model", 
                 value="moonshotai/Kimi-K2-Instruct-0905",
                 choices=COMMON_MODELS,
                 allow_custom_value=True,
-                info="Choisissez un modèle optimisé pour le code ou tapez-en un nouveau."
+                info="Choose a code-optimized model or type a new one."
             )
             
-            # Mise à jour dynamique des modèles
+            # Dynamic model update
             def update_models(provider: str):
                 models = PROVIDER_MODELS.get(provider, PROVIDER_MODELS["default"])
                 return gr.update(choices=models, value=models[0] if models else "")
 
             provider_id.change(update_models, inputs=[provider_id], outputs=[model_id])
 
-        btn_init = gr.Button("Initialiser le projet & proposer le code (IA)")
-        out_init = gr.JSON(label="Résultat (Copiez le draft_id)")
+        btn_init = gr.Button("Initialize Project & Propose Code (AI)")
+        out_init = gr.JSON(label="Result (Copy the draft_id)")
         
 
-    with gr.Tab("2. Précision de la logique"):
-        gr.Markdown("Vérifiez et précisez le code Python et l'interface de votre outil.")
+    with gr.Tab("2. Logic Definition"):
+        gr.Markdown("Verify and refine the Python code and interface of your tool.")
         
-        # Afficher le rappel du draft_id en lecture seule pour assurer la propagation
+        # Display draft_id as read-only to ensure propagation
         draft_id_logic = gr.Textbox(label="Draft ID", interactive=False)
         
         with gr.Row():
-            # Colonne de gauche : Code
+            # Left Column: Code
             with gr.Column(scale=2):
-                python_code = gr.Code(language="python", label="Code Python (ex: def count_r(word): ...)")
+                python_code = gr.Code(language="python", label="Python Code (e.g. def count_r(word): ...)")
             
-            # Colonne de droite : Requirements, Inputs, Outputs
+            # Right Column: Requirements, Inputs, Outputs
             with gr.Column(scale=1):
                 # 1. Requirements
                 requirements_box = gr.Code(language="json", label="Requirements (JSON List)", value='[]')
@@ -435,16 +441,16 @@ with gr.Blocks(title="MCePtion") as demo:
                 inputs_dict = gr.Code(language="json", label="Inputs (JSON)", value='{"word": "text"}')
                 
                 # 3. Outputs
-                output_desc = gr.Textbox(label="Description de la sortie")
+                output_desc = gr.Textbox(label="Output Description")
                 output_component_ui = gr.Dropdown(
-                    label="Type de sortie (Composant Gradio)", 
+                    label="Output Type (Gradio Component)", 
                     choices=["text", "image", "audio", "video", "html", "json", "file"],
                     value="text",
                     interactive=True
                 )
             
-        btn_logic = gr.Button("Valider le code")
-        out_logic = gr.JSON(label="Résultat")
+        btn_logic = gr.Button("Validate Code")
+        out_logic = gr.JSON(label="Result")
             
         btn_logic.click(
             step_2_logic_definition, 
@@ -453,48 +459,48 @@ with gr.Blocks(title="MCePtion") as demo:
             api_name="step_2_logic_definition"
         )
 
-    with gr.Tab("3. Déploiement"):
-        gr.Markdown("Déployez votre outil sur Hugging Face Spaces.")
+    with gr.Tab("3. Deployment"):
+        gr.Markdown("Deploy your tool to Hugging Face Spaces.")
         with gr.Row():
             draft_id_deploy = gr.Textbox(label="Draft ID")
-            # Simplification: Pas d'autres inputs nécessaires
+            # Simplification: No other inputs needed
         
-        # Résumé du plan de déploiement (calculé dynamiquement)
-        deployment_summary = gr.Markdown("En attente du Draft ID...")
+        # Deployment plan summary (dynamically calculated)
+        deployment_summary = gr.Markdown("Waiting for Draft ID...")
         
         def update_deployment_summary(draft_id: str):
             if not draft_id:
-                return "En attente..."
+                return "Waiting..."
             
-            # Logique simplifiée miroir de tools.deploy_to_space
+            # Simplified logic mirroring tools.deploy_to_space
             default_space = os.environ.get("DEFAULT_SPACE")
-            target = default_space if default_space else "Nouveau Space (Nom du projet)"
-            mode = "AJOUT (Toolbox)" if default_space else "CRÉATION (Nouveau Space)"
+            target = default_space if default_space else "New Space (Project Name)"
+            mode = "ADD (Toolbox)" if default_space else "CREATE (New Space)"
             
             return f"""
-            ### 📋 Résumé du déploiement
+            ### 📋 Deployment Summary
             
-            *   **Mode :** {mode}
-            *   **Cible :** `{target}`
-            *   **Visibilité :** Public
+            *   **Mode:** {mode}
+            *   **Target:** `{target}`
+            *   **Visibility:** Public
             
-            Si vous utilisez un `DEFAULT_SPACE`, l'outil sera ajouté à votre toolbox existante sans écraser les autres outils.
-            Sinon, un nouveau Space dédié sera créé.
+            If you use a `DEFAULT_SPACE`, the tool will be added to your existing toolbox without overwriting other tools.
+            Otherwise, a new dedicated Space will be created.
             """
 
-        btn_deploy = gr.Button("Déployer sur Spaces", variant="primary")
+        btn_deploy = gr.Button("Deploy to Spaces", variant="primary")
         
         out_status = gr.Markdown("")
         
         with gr.Row():
-            # Utilisation de gr.Code car gr.Textbox(show_copy_button=True) n'est pas supporté dans cette version de Gradio
-            out_space_url = gr.Code(language=None, label="URL du Space Hugging Face", interactive=False, lines=1)
-            out_mcp_url = gr.Code(language=None, label="URL du Point d'accès MCP", interactive=False, lines=1)
+            # Using gr.Code because gr.Textbox(show_copy_button=True) is not supported in this Gradio version
+            out_space_url = gr.Code(language=None, label="Hugging Face Space URL", interactive=False, lines=1)
+            out_mcp_url = gr.Code(language=None, label="MCP Endpoint URL", interactive=False, lines=1)
             
-        out_claude_config = gr.Code(language="json", label="Configuration Claude Desktop (à ajouter à claude_desktop_config.json)")
+        out_claude_config = gr.Code(language="json", label="Claude Desktop Configuration (add to claude_desktop_config.json)")
         
-        with gr.Accordion("Détails JSON (Debug)", open=False):
-            out_deploy = gr.Code(language="json", label="Résultat Brut")
+        with gr.Accordion("JSON Details (Debug)", open=False):
+            out_deploy = gr.Code(language="json", label="Raw Result")
         
         # Mise à jour du résumé quand le draft_id change
         draft_id_deploy.change(update_deployment_summary, inputs=[draft_id_deploy], outputs=[deployment_summary])
@@ -519,37 +525,37 @@ with gr.Blocks(title="MCePtion") as demo:
     )
 
     with gr.Tab("4. Test & Playground (Smolagents)"):
-        gr.Markdown("Testez immédiatement votre serveur MCP déployé.")
+        gr.Markdown("Immediately test your deployed MCP server.")
         
         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",
+                label="MCP Server URL", 
+                placeholder="e.g. https://your-user-your-space.hf.space/gradio_api/mcp/sse",
                 scale=3
             )
-            btn_reload = gr.Button("🔄 Charger les outils", scale=1)
+            btn_reload = gr.Button("🔄 Load Tools", scale=1)
         
         status_msg = gr.Markdown("")
         
-        # Tableau adapté pour l'affichage des outils (wrap=True)
+        # Table adapted for tool display (wrap=True)
         tool_table = gr.DataFrame(
             headers=["Tool name", "Description", "Params"], 
-            label="Outils détectés",
+            label="Detected Tools",
             wrap=True,
             interactive=False
         )
         
         gr.Markdown("""
-        ### ⚙️ Configuration Smolagents
-        Pour utiliser cet outil avec smolagents dans votre code :
+        ### ⚙️ Smolagents Configuration
+        To use this tool with smolagents in your code:
         ```python
         from smolagents import MCPClient
-        # Mode HTTP direct (recommandé)
-        client = MCPClient(url="URL_DU_SERVEUR", structured_output=False) 
+        # Direct HTTP Mode (recommended)
+        client = MCPClient(url="SERVER_URL", structured_output=False) 
         ```
         """)
         
-        gr.Markdown("### 🤖 Discutez avec votre Agent MCP")
+        gr.Markdown("### 🤖 Chat with your MCP Agent")
         chatbot = gr.ChatInterface(
             fn=chat_response_handler
         )
@@ -566,11 +572,37 @@ with gr.Blocks(title="MCePtion") as demo:
         try:
             with open("README.md", "r", encoding="utf-8") as f:
                 readme_content = f.read()
+            
+            # Remove Hugging Face YAML frontmatter if present
+            if readme_content.startswith("---"):
+                try:
+                    # Find the end of the frontmatter (second '---')
+                    # We start searching from index 3 to skip the first '---'
+                    end_index = readme_content.find("---", 3)
+                    if end_index != -1:
+                        # Slice content after the second '---' and strip leading whitespace
+                        readme_content = readme_content[end_index + 3:].lstrip()
+                except Exception:
+                    pass
+                    
         except Exception as e:
-            readme_content = f"Impossible de charger le README.md : {str(e)}"
+            readme_content = f"Unable to load README.md: {str(e)}"
+        
+        # Le conteneur Row pour aligner les 3 colonnes horizontalement
+        with gr.Row():
             
-        with gr.Column():
-            gr.Markdown(readme_content)
+            # 1. Colonne vide à gauche (1 part)
+            # min_width=0 est important pour que la colonne puisse rétrécir si besoin
+            with gr.Column(scale=1, min_width=0):
+                pass 
+            
+            # 2. Colonne centrale avec le contenu (3 parts)
+            with gr.Column(scale=3):
+                gr.Markdown(readme_content)
+                
+            # 3. Colonne vide à droite (1 part)
+            with gr.Column(scale=1, min_width=0):
+                pass
 
     # Câblage différé du déploiement (pour avoir accès à mcp_url_input défini dans le Tab 4)
     btn_deploy.click(

src/mcp_server/tools.py

@@ -16,13 +16,13 @@ session_manager = SessionManager()
 
 def init_project(project_name: str, description: str, type: str = "adhoc") -> Dict[str, Any]:
     """
-    Crée un nouveau projet vide.
+    Creates a new empty project.
     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).
+        project_name: Technical name (e.g. strawberry-counter, ratp-api).
+        description: Tool description, or complete Technical Specification (e.g. content of a Swagger/OpenAPI JSON).
+        type: 'adhoc' (pure code), 'api_wrapper' (REST).
     Returns:
-        Un dictionnaire contenant le 'draft_id' nécessaire pour la suite.
+        A dictionary containing the 'draft_id' required for next steps.
     """
     print(f"DEBUG [init_project]: project_name={project_name}, type={type}")
     draft = session_manager.create_draft(project_name, description, type)
@@ -33,20 +33,20 @@ def init_project(project_name: str, description: str, type: str = "adhoc") -> Di
             "description": draft.description,
             "files": list(draft.code_files.keys())
         },
-        "message": f"Projet '{project_name}' initialisé. Draft ID: {draft.draft_id}"
+        "message": f"Project '{project_name}' initialized. Draft ID: {draft.draft_id}"
     }
     print(f"DEBUG [init_project]: result={result}")
     return result
 
 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.
+    Uses internal AI to propose a complete implementation from a description or Swagger.
     Args:
-        project_name: Le nom du projet.
-        description: La description ou le JSON Swagger/OpenAPI.
+        project_name: The project name.
+        description: The description or Swagger/OpenAPI JSON.
     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.
+        A dictionary containing the proposed Python code, detected inputs, and requirements.
+        The calling agent can then validate or modify this code before calling define_logic.
     """
     print(f"DEBUG [propose_implementation]: project_name={project_name}")
     try:
@@ -54,26 +54,26 @@ def propose_implementation(project_name: str, description: str) -> Dict[str, Any
         result = {
             "status": "success",
             "proposal": proposal,
-            "message": "Implémentation proposée. Veuillez réviser 'python_code' et 'requirements' avant d'appeler define_logic."
+            "message": "Implementation proposed. Please review 'python_code' and 'requirements' before calling define_logic."
         }
         print(f"DEBUG [propose_implementation]: result={result.keys()}")
         return result
     except Exception as e:
         print(f"DEBUG [propose_implementation]: error={str(e)}")
-        return {"error": f"Erreur lors de la génération: {str(e)}"}
+        return {"error": f"Error during generation: {str(e)}"}
 
 def define_logic(draft_id: str, python_code: str, inputs: Union[Dict[str, str], str], output_desc: str, requirements: str = "", output_component: str = "text") -> Dict[str, Any]:
     """
-    Définit la logique interne de l'outil.
+    Defines the internal logic of the tool.
     Args:
-        inputs: Dictionnaire des inputs (ex: {"word": "text"}). Peut être une string JSON.
-        output_component: Type de composant Gradio de sortie (text, image, audio, video, html, json, file).
+        inputs: Dictionary of inputs (e.g. {"word": "text"}). Can be a JSON string.
+        output_component: Output Gradio component type (text, image, audio, video, html, json, file).
     """
     print(f"DEBUG [define_logic]: draft_id={draft_id}, output_component={output_component}")
     draft = session_manager.get_draft(draft_id)
     if not draft:
         print(f"DEBUG [define_logic]: Draft not found")
-        return {"error": f"Draft {draft_id} introuvable."}
+        return {"error": f"Draft {draft_id} not found."}
 
     # Gestion des inputs (Dict ou JSON String)
     if isinstance(inputs, str):
@@ -138,19 +138,19 @@ def define_logic(draft_id: str, python_code: str, inputs: Union[Dict[str, str],
 
     return {
         "status": "success",
-        "message": f"Logique générée pour '{draft.name}'. Prêt à déployer.",
+        "message": f"Logic generated for '{draft.name}'. Ready to deploy.",
         "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.
+    Deploys the project to Hugging Face Spaces.
     """
     print(f"DEBUG [deploy_to_space]: draft_id={draft_id}, target={space_target}, name={target_space_name}")
     draft = session_manager.get_draft(draft_id)
     if not draft:
-        return {"error": f"Draft {draft_id} introuvable."}
+        return {"error": f"Draft {draft_id} not found."}
 
     deployer = HFDeployer()
     
@@ -257,9 +257,9 @@ def deploy_to_space(draft_id: str, visibility: str = "public", space_target: str
             private=(visibility == "private")
         )
         
-        mode_msg = "ajouté à la toolbox" if space_target == "existing" else "déployé (nouveau space)"
+        mode_msg = "added to toolbox" if space_target == "existing" else "deployed (new space)"
         
-        # URL standard MCP pour Gradio
+        # Standard MCP URL for Gradio
         mcp_endpoint = url.rstrip("/") + "/gradio_api/mcp/"
         
         # Nom du serveur pour la config Claude (nom du Space sans le username)
@@ -289,23 +289,23 @@ def deploy_to_space(draft_id: str, visibility: str = "public", space_target: str
         return {
             "status": "success",
             "url": url,
-            "instructions": f"Outil '{draft.name}' {mode_msg} !",
+            "instructions": f"Tool '{draft.name}' {mode_msg} !",
             "claude_config": claude_config
         }
     except Exception as e:
-        return {"error": f"Erreur de déploiement: {str(e)}"}
+        return {"error": f"Deployment error: {str(e)}"}
 
 def delete_tool(space_name: str, tool_name: str) -> Dict[str, Any]:
     """
-    Supprime un outil d'un Space existant.
+    Deletes a tool from an existing Space.
     Args:
-        space_name: Nom complet du Space (ex: user/space) ou nom court (si HF_USER configuré).
-        tool_name: Nom de l'outil (ex: strawberry_counter).
+        space_name: Full Space name (e.g. user/space) or short name (if HF_USER configured).
+        tool_name: Tool name (e.g. strawberry_counter).
     """
     deployer = HFDeployer()
     api = HfApi(token=deployer.token)
     
-    # Résolution du nom du repo
+    # Repo name resolution
     repo_id = space_name
     if "/" not in repo_id:
         hf_user = os.environ.get("HF_USER")
@@ -322,17 +322,17 @@ def delete_tool(space_name: str, tool_name: str) -> Dict[str, Any]:
             repo_type="space",
             commit_message=f"Delete tool {tool_name} via Meta-MCP"
         )
-        return {"status": "success", "message": f"Outil '{tool_name}' supprimé de '{repo_id}'."}
+        return {"status": "success", "message": f"Tool '{tool_name}' deleted from '{repo_id}'."}
     except Exception as e:
         print(f"DEBUG [delete_tool]: Error: {e}")
-        return {"error": f"Erreur lors de la suppression : {str(e)}"}
+        return {"error": f"Error during deletion: {str(e)}"}
 
 def get_tool_code(space_name: str, tool_name: str) -> Dict[str, Any]:
     """
-    Récupère le code source d'un outil existant.
+    Retrieves the source code of an existing tool.
     Args:
-        space_name: Nom complet du Space (ex: user/space).
-        tool_name: Nom de l'outil.
+        space_name: Full Space name (e.g. user/space).
+        tool_name: Tool name.
     """
     deployer = HFDeployer()
     
@@ -358,4 +358,4 @@ def get_tool_code(space_name: str, tool_name: str) -> Dict[str, Any]:
         return {"status": "success", "code": code}
     except Exception as e:
         print(f"DEBUG [get_tool_code]: Error: {e}")
-        return {"error": f"Erreur lors de la lecture du code : {str(e)}"}
+        return {"error": f"Error reading code: {str(e)}"}