sentra-mcp

Serveur MCP minimal construit avec FastAPI et la librairie officielle mcp[server]. Il expose un flux SSE compatible ChatGPT Developer Mode et fournit deux outils de démonstration (ping, time).

Caractéristiques

• Serveur FastMCP (SSE) monté dans FastAPI (/sse en GET + POST JSON-RPC sur la même route).

• Healthcheck REST GET /health pour la supervision.

• Deux outils MCP :

  • ping → {"message": "pong"}

  • time → {"utc": "<timestamp ISO-8601>"}

• Configuration via .env (nom du service, instructions, chemins SSE, port, niveau de logs).

• Dockerfile basé sur python:3.12-slim et orchestration docker-compose (port 8400).

Structure du dépôt

• mcp/ – package applicatif (configuration + app FastAPI/MCP).

• docker/ – artefacts de conteneurisation (Dockerfile, Caddyfile).

• docker-compose.yml – stack API + proxy optionnel.

• .env.example – gabarit d’environnement.

• requirements.txt – dépendances Python.

Démarrage local

1. Préparer un environnement virtuel et installer les dépendances :

   python -m venv .venv
   source .venv/bin/activate
   pip install -r requirements.txt

2. Copier .env.example vers .env si besoin et ajuster.

3. Lancer le serveur :

   uvicorn mcp.main:app --host 0.0.0.0 --port 8400 --reload

4. Vérifier la santé :

   curl -fsSL http://localhost:8400/health

5. Tester le flux MCP SSE (exemple manuel) :

   # 1) Ouvrir une connexion SSE et récupérer le point de POST retourné (event "endpoint")
   curl -N http://localhost:8400/sse
   # 2) Dans un autre terminal, envoyer un appel JSON-RPC vers le point retourné
   curl -fsSL -X POST "http://localhost:8400/sse?session_id=<ID>" \
     -H 'Content-Type: application/json' \
     --data '{"jsonrpc":"2.0","id":"1","method":"call_tool","params":{"name":"time","arguments":{}}}'

Docker & Compose

cp .env.example .env
# Démarrer l’API (et Caddy si besoin d’un reverse proxy HTTPS)
docker compose up --build

• L’API MCP écoute sur http://localhost:8400.

• Activer le profil reverse-proxy si vous souhaitez l’HTTPS géré par Caddy : docker compose --profile reverse-proxy up -d.

Supervision & restart

Le docker-compose.yml applique un healthcheck (/health) toutes les 30s et restart: unless-stopped.

Validation (local ou VPS)

1. docker compose up --build ou déployer l’image sur votre VPS.

2. Consulter les logs : docker compose logs -f api.

3. Vérifier :

   curl -fsSL http://<hote>:8400/health
   curl -N http://<hote>:8400/sse      # récupérer l’event endpoint
   curl -fsSL -X POST "http://<hote>:8400/sse?session_id=<ID>" \
     -H 'Content-Type: application/json' \
     --data '{"jsonrpc":"2.0","id":"1","method":"call_tool","params":{"name":"ping","arguments":{}}}'

4. docker ps pour confirmer que seuls les services MCP sont exposés.

5. Surveiller la charge (htop, docker stats).

Intégration ChatGPT Developer Mode

1. Publier l’URL HTTPS du service (reverse proxy / Caddy / Cloudflare Tunnel).

2. Vérifier le certificat TLS.

3. Dans ChatGPT → Connectors → Developer Mode, déclarer l’URL MCP (point /sse).

4. Valider que les outils ping et time apparaissent et répondent.

Préparation VPS (rappel)

• Inventorier CPU/RAM/disques : lscpu, free -h, df -h /.

• Nettoyer Docker (docker container/image/volume/system prune).

• Couper les services en conflit (sudo ss -tulpn | grep ':8400').

• Mettre à jour la machine (sudo apt update && sudo apt upgrade -y).

• Revoir le pare-feu OVH + ufw / nftables pour limiter les IP autorisées.

Pistes d’évolution

• Ajouter des outils riches (git.commit_push, files.write, n8n.trigger, doc.index, doc.query, ...).

• RAG local (embeddings CPU + Chroma/FAISS).

• Authentification (OAuth/Bearer), RBAC, quotas, métriques Prometheus.

• Durcissement réseau (rate limiting, WAF, mTLS interne).

• Provisionnement infra (Terraform + Ansible) et observabilité.