IA & Robotique : Piloter l'Esieabot via le protocole MCP

1. Introduction : Le projet Esieabot

L’Esieabot est le robot pédagogique emblématique de l’ESIEA. Basé sur un micro-ordinateur Raspberry Pi, il est le terrain d’expérimentation privilégié pour l’apprentissage de l’électronique, du réseau et de la programmation système.

Traditionnellement, un robot se pilote via une télécommande ou un script pré-enregistré. L’objectif de ce projet est de briser cette barrière : permettre à une Intelligence Artificielle (Claude) de “prendre possession” du robot pour exécuter des ordres complexes donnés en langage naturel.

---

2. Le Concept : Qu’est-ce que le protocole MCP ?

Le Model Context Protocol (MCP) est une innovation majeure introduite par Anthropic.

Analogie

Imaginez que l’IA soit un cerveau brillant mais enfermé dans une boîte sans mains. Le protocole MCP est le système nerveux qui permet à ce cerveau de se connecter à des outils extérieurs (moteurs, caméras, bases de données) de manière standardisée.

Grâce au MCP, l’IA ne se contente pas de “parler” du robot : elle peut interroger ses capteurs et actionner ses moteurs en comprenant d’elle-même les capacités du matériel.

---

3. Architecture Technique : Le choix de l’autonomie

Pour ce projet, j’ai implémenté une architecture dite “embarquée”. Le but était de faire tourner le serveur MCP directement sur le Raspberry Pi du robot, plutôt que d’avoir un serveur externe sur un PC qui communiquerait avec le robot via SSH ou une API.

┌─────────────────────────────────────────────────────────────────────────┐
│                 ARCHITECTURE A — MCP SUR LE PI                          │
├─────────────────────────────────────────────────────────────────────────┤
│                                                                         │
│   Votre PC                                       Raspberry Pi           │
│   ┌───────────────┐    HTTP (port 8000)     ┌──────────────────┐        │
│   │  Claude       │ ◄─────────────────────► │  Serveur MCP     │        │
│   │  Desktop      │    JSON-RPC 2.0         │  (server.py)     │        │
│   │  (client MCP) │                         │       │          │        │
│   └───────────────┘                         │       ▼          │        │
│                                             │  ┌────────────┐  │        │
│                                             │  │ pigpiod    │  │        │
│                                             │  │ (GPIO)     │  │        │
│                                             │  ├────────────┤  │        │
│                                             │  │ Moteurs    │  │        │
│                                             │  │ Servos     │  │        │
│                                             │  │ Caméra     │  │        │
│                                             │  └────────────┘  │        │
│                                             └──────────────────┘        │
│                                                                         │
│   ✅ Tout est sur le robot, autonome                                    │
│                                                                         │
└─────────────────────────────────────────────────────────────────────────┘

Pourquoi ce choix ?

En plaçant le serveur MCP directement sur le Raspberry Pi du robot, celui-ci devient une entité intelligente indépendante sur le réseau. Je trouvais cette architecture plus fun !

Focus Sécurité

L’intelligence est décentralisée. Le robot n’est pas un simple “esclave” d’un PC, mais un serveur sécurisé qui expose ses fonctions d’audit et de patrouille.

---

4. Réalisation du système

La structure modulaire

Le code a été conçu pour être robuste et facile à maintenir, en séparant strictement chaque fonction vitale du robot :

1. Pilotage Moteur (motors.py) : Gestion des déplacements (Avancer, tourner, s’arrêter).
2. Vision Artificielle (camera.py) : Capture de preuves visuelles et transmission à l’IA.
3. Système Nerveux (server.py) : Le serveur MCP qui fait le pont entre le code Python et l’IA Claude.

• Directorymcp-esieabot/

  • .gitignore
  • pyproject.toml ← Auto-détection pigpio (stub / local / remote)
  • server.py ← Serveur MCP principal
  • Directorylivrable/ ← Contient les photos “livrable” pour notation

    • …
  • Directoryrobot/

    • __init__.py ← Auto-détection pigpio (stub / local / remote)
    • motors.py ← Contrôle des moteurs
    • servos.py ← Contrôle des servomoteurs
    • camera.py ← Capture photo (locale ou SSH)
    • stub.py ← Faux pigpio pour dev local (PC)
  • README.md

Gestion des risques (Safety)

Un point d’honneur a été mis sur la sécurité physique. En robotique, un bug logiciel peut entraîner un dommage matériel. J’ai utilisé le mécanisme de lifespan pour garantir qu’en cas de déconnexion ou d’erreur, les moteurs se coupent instantanément (Fail-Safe).

---

5. L’IA au cœur du robot : Comment Claude comprend-il le MCP ?

Le catalogue d’outils : La clé de l’intelligence physique

L’IA utilise le décorateur @mcp.tool() pour découvrir le “catalogue” des fonctions du robot. Elle ne voit pas du code, mais une description structurée (JSON-RPC) qui lui indique : “Voici comment faire avancer le robot et quels paramètres utiliser.” Voici quelques outils disponible sur l’esieabot :

Outils disponibles sur le robot

Réponse du robot après un ping

Zoom sur un code d’outil : identify

Rien de mieux qu’un exemple pour bien comprendre le fonctionnement d’une technologie.

Aperçu du Code

@mcp.tool()
def identify(verbose: bool = False) -> str:
"""Retourne les informations d'identification du robot."""
import socket
import platform

info = f"esieabot — {socket.gethostname()}"
if verbose:
    info += f"\n  OS: {platform.platform()}"
    if platform.system() == "Linux":
        import subprocess
        uptime = subprocess.check_output(["uptime", "-p"]).decode().strip()
        ip = subprocess.check_output(["hostname", "-I"]).decode().strip().split()[0]
        info += f"\n  IP: {ip}"
        info += f"\n  Uptime: {uptime}"
    else:
        info += f"\n  IP: {socket.gethostbyname(socket.gethostname())}"
        info += "\n  Uptime: N/A (Windows)"
return info

Réponse du robot

  result: "esieabot - esieabot-d1f104
  OS: Linux-6.6.31+rpt-rpi-v6-armv6l-with-glibc2.36
  IP: 192.168.1.105
  Uptime: up 1 hour, 20 minutes"

L’outil identify illustre parfaitement la philosophie du protocole MCP :

1. Exposition dynamique : Grâce au décorateur @mcp.tool(), la fonction est automatiquement enregistrée dans le catalogue de capacités du robot. Claude “découvre” alors l’existence de cette commande et sa documentation sans aucune configuration manuelle.
2. Granularité des données : L’utilisation du paramètre verbose permet à l’IA de choisir le niveau de détail souhaité. En mode standard, elle obtient le nom du robot ; en mode détaillé, elle récupère des informations critiques pour l’administration système (IP, OS, Uptime).
3. Abstraction matérielle : Le code reste simple, mais sa portée est immense : il transforme des données système brutes en une réponse structurée que l’IA peut interpréter pour diagnostiquer l’état du réseau ou de la machine.

C’est cette simplicité de mise en œuvre qui fait du MCP un standard redoutable pour l’IoT et la robotique.

Comment utiliser le servomoteur ?

Si vous utilisez un servomoteur pour orienter la caméra du robot, une conversion mathématique est nécessaire entre l’angle souhaité (en degrés) et le signal électrique (PWM) envoyé au moteur : Signal (µs) = 500 + ((Angle / 180) * 2000)

La caméra

Notre robot est équipé d’une caméra compatible CSI, offrant une résolution de 8MP. Pour capturer une photo, j’utilise la bibliothèque libcamera-still en subprocess qui interagit directement avec le matériel de la caméra.

Pourquoi pas OpenCV ou picamera2?

OpenCV et picamera2 sont des bibliothèques puissantes pour le traitement d’images, mais elles peuvent être lourdes à installer et à faire fonctionner sur un Raspberry Pi 0. libcamera-still est plus léger et optimisé pour les caméras CSI, ce qui garantit une capture rapide et fiable.

Code de capture de la caméra

import subprocess
from pathlib import Path
from datetime import datetime

class CameraController:
    def __init__(self, capture_dir: str = "/tmp/esieabot_captures"):
        self.capture_dir = Path(capture_dir)
        self.capture_dir.mkdir(parents=True, exist_ok=True)

    def capture(self) -> dict:
        """Prend une photo et renvoie le chemin du fichier."""
        timestamp = datetime.now().strftime("%Y%m%d_%H%M%S")
        filename = f"capture_{timestamp}.jpg"
        filepath = self.capture_dir / filename

        try:
            subprocess.run([
                "libcamera-still",
                "-o", str(filepath),
                "--width", "640",
                "--height", "480",
                "-t", "500",
                "--nopreview",
                "--hflip",
                "--vflip"
            ], check=True, capture_output=True, timeout=15)

            if not filepath.exists():
                return {"status": "error", "message": "Le fichier n'a pas été créé."}

            return {
                "status": "success",
                "path": str(filepath.absolute())
                }
        except Exception as e:
            return {"status": "error", "message": str(e)}

Réponse du robot après capture

---

6. Claude, l’IA qui pilote le robot

Claude, développé par Anthropic, est une IA de nouvelle génération conçue pour être plus sûre et plus contrôlable que les modèles précédents. Grâce au protocole MCP, Claude peut interagir avec le robot de manière intelligente, en comprenant les capacités du matériel et en adaptant ses commandes en fonction du contexte. Voici comment installer le client MCP sur votre machine pour communiquer avec le robot :

1. Naviguer jusqu’au fichier claude_desktop_config.json dans le répertoire \AppData\Local\Packages\Claude_pzs8sxrjxfjjc\LocalCache\Roaming\Claude sur Windows
2. Ajouter la configuration suivante pour le client MCP :

"mcpServers": {
    "esieabot": {
      "command": "npx",
      "args": [
        "mcp-remote",
        "http://192.168.1.105:8000/mcp",
        "--allow-http"
      ]
    }
  }

3. Redémarrer Claude Desktop pour que les changements prennent effet.

7. Le déploiement sur le Raspberry Pi 0 : Un défi de taille (mémoire)

Le déploiement du serveur MCP sur le Raspberry Pi 0 a été l’étape la plus complexe du projet. Avec seulement 512 Mo de RAM, le Pi 0 est un matériel très limité, et les bibliothèques modernes utilisées par le SDK MCP sont gourmandes en ressources.

Le piège de la compilation

Le SDK MCP (mcp[cli]) dépend de bibliothèques modernes (comme pydantic-core) qui nécessitent souvent une compilation Rust/C lors de l’installation. Sur le processeur limité du Pi 0, cette étape provoque systématiquement des erreurs de mémoire (OOM) ou prend plusieurs heures.

La solution : Piwheels

Pour contourner ce problème, j’ai configuré Poetry pour utiliser les dépôts de piwheels.org. Cela permet de télécharger des binaires déjà compilés pour ARMv6, rendant l’installation instantanée et stable sur le matériel d’origine de l’Esieabot.

Mis à part cela, l’installation a été relativement fluide, et le serveur MCP a pu être lancé sans encombre sur le Pi 0, démontrant ainsi la viabilité de l’architecture choisie.

8. Test en conditions réelles

Voici une vidéo de démonstration du robot en action, exécutant des commandes données par l’IA Claude via le protocole MCP :

9. Bilan : Arbitrage Performance vs Fonctionnalités

Ce projet a été un véritable exercice d’ingénierie sous contrainte. Sur un matériel aussi modeste que le Raspberry Pi 0, chaque outil (tool) ajouté consomme des ressources critiques.

Une réflexion stratégique sur les Tools

J’ai dû mener une réflexion approfondie sur le choix des outils à implémenter :

• Optimisation du catalogue : Plutôt que de multiplier les fonctions lourdes, j’ai privilégié des outils “atomiques” et légers pour ne pas saturer le processeur lors de l’analyse de Claude.
• Réduction de la latence : Chaque import Python a été scruté pour garantir que le robot réponde en temps réel. Un catalogue trop chargé aurait rendu l’interaction avec l’IA saccadée ou instable.

Conclusion : Ce projet démontre que l’IA physique est possible, même sur du matériel “low-cost”, à condition de faire des choix d’architecture cohérents. En cybersécurité, cette capacité à optimiser des systèmes contraints est une force pour déployer des solutions de terrain agiles et autonomes. Ressources du projet :

• Lien vers le code source (GitLab)
• Cours de Sébastien LARINIER & Alexandre LEBLANC (un grand merci à eux pour leur enseignement inspirant et ce projet passionnant !)