Serveur MCP PingZen : 126 outils de monitoring

Intégrer PingZen comme serveur MCP : 126 outils pour agents IA

Le serveur MCP s'exécute aux côtés de l'application principale dans un même processus, mais avec des points d'accès isolés. STDIO est idéal pour les agents bureau lançant des scripts Python via stdin/stdout. Le transport HTTP est intégré à FastAPI pour les services hébergés dans le cloud.

L'enregistrement des 126 outils se fait via des décorateurs SDK. Les outils sont regroupés ainsi :

• Moniteurs : create_monitor, update_monitor, delete_monitor, get_monitor_status, list_monitors, pause_monitor, resume_monitor.
• Alertes : create_alert, update_alert, test_alert, list_alerts.
• Incidents : list_incidents, get_incident_details, resolve_incident, add_incident_update.
• Pulsations : create_heartbeat, send_heartbeat_ping, get_heartbeat_status.
• Pages de statut : create_status_page, add_monitor_to_status_page, update_status_page.
• Webhooks : create_webhook, list_webhooks.
• Rapports : create_scheduled_report, get_report_history.
• Clés API : create_api_key, revoke_api_key.

Exemple d'enregistrement :

from mcp.server import Server
import mcp.types as types

server = Server("pingzen-mcp")

@server.list_tools()
async def handle_list_tools() -> list[types.Tool]:
    return [
        types.Tool(
            name="create_monitor",
            description="Créer un nouveau moniteur",
            inputSchema={
                "type": "object",
                "properties": {
                    "name": {"type": "string"},
                    "type": {"type": "string", "enum": ["http", "tcp", "udp", "icmp", "dns", "smtp", "transaction", ...]},
                    "target": {"type": "string"},
                    "interval": {"type": "integer", "minimum": 60},
                },
                "required": ["name", "type", "target"]
            }
        ),
    ]

@server.call_tool()
async def handle_call_tool(name: str, arguments: dict) -> list[types.TextContent]:
    if name == "create_monitor":
        monitor = await monitor_service.create(arguments)
        return [types.TextContent(type="text", text=json.dumps(monitor.to_dict()))]

Les arguments sont passés sous forme de schéma JSON, simplifiant la définition de protocoles complexes comme Transaction via Playwright.

Authentification OAuth 2.0

OAuth 2.0 est implémenté selon le RFC 9728, sans configuration nécessaire. Les agents ouvrent un navigateur pour s'authentifier via Telegram, Google ou Yandex. Après accord, un jeton est délivré. Pour les pipelines CI/CD, les clés API sont disponibles via des variables d’environnement. Il suffit de définir l’URL https://pingzen.dev/mcp dans les paramètres de l’agent.

Utilisation pratique des outils

Création d’un moniteur HTTP :

{
  "name": "create_monitor",
  "arguments": {
    "name": "Habr",
    "type": "http",
    "target": "https://habr.com",
    "interval": 60,
    "alert_channels": ["telegram"]
  }
}

Résultat : ID du moniteur et confirmation. Cela fonctionne de la même manière pour list_monitors, resolve_incident ou la pulsation avec une intervalle de 24 heures et une période de grâce de 1 heure.

Subtilités d’implémentation

• Validation : Le schéma JSON impose un typage strict. Un casting explicite est appliqué dans les gestionnaires (ex. : intervalle en entier), même si l’IA renvoie une chaîne.

• Synchronisation : Tous les outils sont synchrones avec délais d’attente. Aucune tâche en arrière-plan pour plus de simplicité.

• Erreurs : Des messages d’erreur centralisés sont définis dans errors.py :

_ERROR_MESSAGES = {
    "INVALID_PROTOCOL": "Type de moniteur invalide '{type}'. Disponibles : http, tcp, udp, icmp, dns, smtp, transaction, ...",
    "TIMEOUT": "La requête a expiré après {timeout} secondes",
}

• Journalisation : La sortie est envoyée via stderr pour STDIO, incluant les arguments appelés.

Points clés

• Les 126 outils couvrent tout le cycle de vie : création de moniteurs jusqu’à la gestion des incidents et la génération de rapports.
• Deux options de transport garantissent une flexibilité totale pour les agents locaux et cloud.
• L’authentification OAuth sans configuration réduit les obstacles au démarrage ; les clés API permettent l’automatisation.
• La conception synchrone avec délais et validation stricte assure un comportement prévisible.
• Une intégration fluide avec CI/CD et les IDEs sans changement de contexte.

— Editorial Team