Version 1.93RC

README.md

@@ -1,86 +1,135 @@
 ---
-title: META MCP
-emoji: 🦀
+title: MCEPTION - Meta MCP Factory
+emoji: 🏭
 colorFrom: purple
 colorTo: pink
 sdk: gradio
-sdk_version: 6.0.0
-app_file: app.py
+sdk_version: 5.9.1
+app_file: src/mcp_server/server.py
 pinned: false
+license: mit
+short_description: Create and deploy MCP servers using natural language.
 ---
 
-# 🏭 Méta-MCP Fractal Factory
+# 🏭 MCEPTION : La Méta-Factory de Serveurs MCP
 
-Le Méta-MCP est une usine logicielle permettant de créer, coder et déployer d'autres serveurs MCP (Model Context Protocol) directement depuis une interface conversationnelle ou via une API.
+**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. 
 
-## 🌟 Concept
+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.
 
-Méta-MCP est un "Serveur MCP créateur de Serveurs MCP". Il permet à des agents IA (comme Claude ou ChatGPT) ou à des utilisateurs humains de créer de nouveaux outils et de les déployer instantanément, étendant ainsi les capacités de l'agent de manière récursive.
+## 🌟 Pourquoi 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. 
+
+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. 
+
+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é. 
+
+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.
+
+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.
+
+## Un workflow intuitif pour les humains et pour les IA
+
+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.
+
+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.
+
+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.
+
+## Merci 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.
 
-```mermaid
-graph TD
-    User[Utilisateur / Agent] -->|1. Décrit l'outil| Meta[🏭 Méta-MCP Server]
-    Meta -->|2. Génère le code| LLM[LLM (Qwen/Kimi)]
-    Meta -->|3. Valide le code| Logic[Validateur Logique]
-    Meta -->|4. Déploie| HF[🤗 Hugging Face Space]
-    HF -->|5. Expose| NewMCP[Nouveau Serveur MCP]
-    NewMCP -->|6. Utilise| User
-```
 
 ## 🚀 Fonctionnalités Clés
 
-1.  **Initialisation Rapide** : Créez un projet en une phrase ("Je veux un outil pour avoir la météo de ma ville") ou via une spec OpenAPI complète.
-2.  **Génération de Code par IA** : Utilise des modèles performants (Qwen 2.5 Coder, etc.) pour produire du code Python prêt à l'emploi.
-3.  **Sandbox & Validation** : Permet de vérifier, éditer et valider le code avant déploiement.
-4.  **Déploiement Automatisé** : Déploie en quelques secondes sur Hugging Face Spaces (soit un nouveau Space dédié, soit en ajoutant l'outil à une "Toolbox" existante).
-5.  **Compatibilité MCP Native** : Les outils générés sont immédiatement utilisables via le protocole MCP (SSE).
+*   **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.
 
-## 🛠️ Installation & Utilisation
+## 🛠️ Architecture
 
-### 1. Installation Locale
 
-```bash
-git clone https://github.com/votre-user/metamcp_proto.git
-cd metamcp_proto
-pip install -r requirements.txt
-export HF_TOKEN=hf_... # Votre token Hugging Face Write
-python src/mcp_server/server.py
-```
+
+## 📚 Installation & Démarrage
+
+### 1. Déploiement Rapide sur Hugging Face Spaces
+
+C'est la méthode recommandée pour utiliser MCEPTION sans installation locale.
+
+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.
+
+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).
+    
+    *Le Space redémarrera automatiquement avec vos droits, prêt à créer de nouveaux Spaces pour vous !*
 
 ### 2. Utilisation avec Claude Desktop
 
-Pour permettre à Claude de créer ses propres outils via Méta-MCP, ajoutez la configuration suivante à votre fichier `claude_desktop_config.json` :
+Pour transformer votre Claude Desktop en "usine à outils", ajoutez la configuration suivante à votre fichier `claude_desktop_config.json` :
 
 ```json
 {
   "mcpServers": {
-    "metamcp": {
+    "mception": {
       "command": "npx",
       "args": [
         "-y",
-        "@modelcontextprotocol/server-sse-client",
-        "--url",
-        "http://localhost:7860/gradio_api/mcp/?tools=step_2_logic_definition,step_1_initialisation_and_proposal,step_3_deployment,step_0_configuration,expert_step1_propose_implementation,expert_step2_define_logic"
+        "@modelcontextprotocol/server-sse",
+        "http://127.0.0.1:7860/gradio_api/mcp/sse"
       ]
     }
   }
 }
 ```
 
-> **Note** : L'URL ci-dessus filtre spécifiquement les outils d'administration du Méta-MCP pour éviter de polluer le contexte avec les outils internes de Gradio.
+> **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`).
+
+## 🤖 Guide pour les Agents (API)
 
-## 📚 Guide Rapide
+MCEPTION expose une suite d'outils MCP permettant à un agent autonome de gérer tout le cycle de vie de création d'outil.
 
-1.  **Onglet Initialisation** : Entrez le nom (ex: `currency-converter`) et la description. Cliquez sur "Initialiser".
-2.  **Onglet Logique** : L'IA propose une implémentation. Vérifiez les `requirements` (ex: `requests`) et le code. Cliquez sur "Valider".
-3.  **Onglet Déploiement** : Cliquez sur "Déployer". Récupérez l'URL de votre nouveau serveur MCP.
-4.  **Profit** : Ajoutez ce nouveau serveur à Claude et profitez de votre nouvel outil !
+### Workflow Typique
 
-## 🤖 API pour Agents
+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.
 
-Ce serveur expose ses fonctionnalités via MCP. Un agent peut donc effectuer toutes ces actions de manière autonome :
+### Liste des Outils Exposés
 
-*   `step_1_initialisation_and_proposal` : Pour commencer un projet.
-*   `step_2_logic_definition` : Pour sauvegarder le code.
-*   `step_3_deployment` : Pour mettre en production.
-*   `expert_...` : Outils avancés pour les agents experts qui veulent bypasser certaines étapes UI.
+| Outil | 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. |
+
+## 💡 Exemple de Prompt pour Claude
+
+Une fois MCEPTION connecté à Claude, vous pouvez lui dire :
+
+> "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."
+
+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 !
+
+---
+*Fait avec ❤️, Python, Gradio et beaucoup d'Agents.*

src/mcp_server/server.py

@@ -275,8 +275,8 @@ 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")
+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.")
 
     with gr.Tab("0. Setup & How-to"):
@@ -316,27 +316,66 @@ with gr.Blocks(title="MCEPTION") as demo:
         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 le Méta-MCP")
-        with gr.Accordion("Guide Utilisateur", open=True):
-            gr.Markdown("""
-            ### 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".
-            
-            ### 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.
+        gr.Markdown("## Comment utiliser ce serveur MCePtion ?")
+        
+        with gr.Row():
+            with gr.Column("Guide Utilisateur"):
+                gr.Markdown("""
+                ## Guide d'utilisation de l'interface humaine
+                
+                ### 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".
+                
+                ### 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.
+                
+                ### 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".
+                
+                ### 4. Test
+                *   Utilisez l'onglet **4. Playground** pour tester votre nouvel outil après son initialisation (environ 1 minute).
+                """)
             
-            ### 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".
+            with gr.Column():
+                # Calcul dynamique des URLs pour affichage
+                _c_space_id = os.environ.get("SPACE_ID", None)
+                _c_space_host = os.environ.get("SPACE_HOST", "localhost:7860")
+                
+                if _c_space_id:
+                    _c_space_url = f"https://huggingface.co/spaces/{_c_space_id}"
+                    _c_mcp_url = f"https://{_c_space_host}/gradio_api/mcp/"
+                    _c_server_name = _c_space_id.split("/")[-1] if "/" in _c_space_id else _c_space_id
+                else:
+                    _c_space_url = "http://localhost:7860"
+                    _c_mcp_url = "http://localhost:7860/gradio_api/mcp/"
+                    _c_server_name = "metamcp-local"
+
+                _c_claude_config = {
+                    "mcpServers": {
+                        _c_server_name: {
+                            "command": "npx",
+                            "args": [
+                                "mcp-remote",
+                                _c_mcp_url,
+                                "--transport",
+                                "streamable-http"
+                            ]
+                        }
+                    }
+                }
+                _c_claude_config_str = json.dumps(_c_claude_config, indent=2)
+                gr.Markdown("""## Paramètres d'intégration MCP""")
+                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)
+
             
-            ### 4. Test
-            *   Utilisez l'onglet **4. Playground** pour tester votre nouvel outil après son initialisation (environ 1 minute).
-            """)
 
     with gr.Tab("1. Initialisation"):
         gr.Markdown("Commencez par initialiser un nouveau projet.")
@@ -530,7 +569,8 @@ with gr.Blocks(title="MCEPTION") as demo:
         except Exception as e:
             readme_content = f"Impossible de charger le README.md : {str(e)}"
             
-        gr.Markdown(readme_content)
+        with gr.Column():
+            gr.Markdown(readme_content)
 
     # Câblage différé du déploiement (pour avoir accès à mcp_url_input défini dans le Tab 4)
     btn_deploy.click(