How to Monitor Your Model Context Provider (MCP) Server

Problem: Ensuring Your MCP Server is Always Responsive

Running a Model Context Provider (MCP) server is critical for your AI applications, but traditional HTTP monitoring often falls short. MCP servers communicate using the JSON-RPC 2.0 protocol, requiring specific request/response patterns that standard health checks don’t cover. How can you confidently ensure your MCP server is healthy and responsive at all times, without custom scripts or complex setups?

Solution: JSON-RPC Ping Monitoring with openstatus

openstatus offers a robust solution for monitoring your MCP servers. By sending precise JSON-RPC ping requests to your endpoint from multiple global locations, openstatus verifies not only network reachability but also the correct functioning of your server’s JSON-RPC interface. This guide will walk you through setting up comprehensive monitoring for any MCP server using the openstatus CLI.

Prerequisites

Before you begin, ensure you have:

An openstatus account.
The openstatus CLI installed. (If you haven’t installed it yet, follow this guide first).
An MCP server with a publicly accessible endpoint.
A basic understanding of the JSON-RPC 2.0 protocol.

Background: Understanding MCP for Monitoring

A Model Context Provider (MCP) is a crucial component that extends AI models with external context, data, or capabilities via the Model Context Protocol (MCP). Essentially, it acts as a bridge, allowing AI models to interact with resources like databases, APIs, or file systems that aren’t part of their core training.

The MCP Server and JSON-RPC 2.0

Step-by-step guide

1. Create your `openstatus.yaml` file

openstatus allows you to define and manage your monitors using a YAML configuration file, which is ideal for GitOps workflows. This approach ensures your monitoring setup is version-controlled, auditable, and easily deployable.

Create a file named openstatus.yaml and add the following configuration, adapting it for your own MCP endpoint. This example targets a Hugging Face MCP server.

# yaml-language-server: $schema=https://www.openstatus.dev/schema.json

mcp-server:
  name: "HF MCP Server"
  description: "Hugging Face MCP server monitoring"
  frequency: "1m"
  active: true
  regions: ["iad", "ams", "lax"]
  retry: 3
  kind: http
  request:
    url: https://hf.co/mcp
    method: POST
    body: >
      {
        "jsonrpc": "2.0",
        "id": "openstatus",
        "method": "ping"
      }
    headers:
      User-Agent: openstatus
      Accept: application/json, text/event-stream
      Content-Type: application/json
  assertions:
    - kind: statusCode
      compare: eq
      target: 200
    - kind: textBody
      compare: eq
      target: '{"result":{},"jsonrpc":"2.0","id":"openstatus"}'

2. Understand the configuration

Let’s break down the key fields in this YAML configuration:

name & description: A human-readable name and explanation for your monitor.
frequency: How often openstatus will run the check (e.g., 1m, 5m, 10m).
regions: An array of geographic regions from which to perform checks (e.g., ["iad", "ams", "lax"]). Monitoring from multiple regions helps detect localized issues.
retry: The number of times to retry a failed check before marking it as down.
kind: Must be http for MCP servers.
request:
- url: The full URL of your MCP server’s JSON-RPC endpoint.
- method: Must be POST for JSON-RPC requests.
- body: The JSON-RPC ping request payload.
- headers: Standard HTTP headers for JSON-RPC communication.
assertions: Rules to validate the server’s response.
- statusCode: Ensures the HTTP response is 200 OK.
- textBody: Verifies that the response payload exactly matches the expected JSON-RPC ping result.

3. Test your MCP server (Optional)

Before deploying your monitor, you can manually test your MCP server’s ping endpoint with curl to confirm it responds as expected. This helps verify the target value for your textBody assertion.

curl -X POST \\
  -H "Content-Type: application/json" \\
  -d '{"jsonrpc": "2.0", "id": "openstatus", "method": "ping"}' \\
  https://hf.co/mcp # Replace with your MCP server URL

A healthy server should return a JSON response like {"result":{},"jsonrpc":"2.0","id":"openstatus"}.

4. Deploy your monitor

Once your openstatus.yaml file is ready, use the openstatus CLI to create the monitor:

openstatus create openstatus.yaml

This command uploads your configuration, and monitoring will begin immediately.

Conclusion: Comprehensive MCP Server Monitoring Achieved

This guide has equipped you with the knowledge to effectively monitor your MCP server using openstatus. By leveraging YAML configuration and the openstatus CLI, you can ensure your critical AI infrastructure remains healthy and responsive.

What You’ve Accomplished

✅ Successfully configured a JSON-RPC based monitor for your MCP server.
✅ Implemented precise assertions to validate ping responses.
✅ Set up global monitoring to detect localized or widespread issues.
✅ Automated monitor deployment using a version-controlled YAML configuration.

Next Steps

Now that your MCP server is under robust monitoring, consider further enhancing your setup:

Set up Alerting: Configure notifications to be immediately informed of any MCP server downtime or performance degradation.
Export Metrics to OTLP: Integrate your MCP monitoring data with your existing observability platform for centralized analytics.
Run Synthetic Tests in GitHub Actions: Incorporate these synthetic checks into your CI/CD pipeline for pre-deployment validation.

JSON-RPC 2.0 Specification: Deep dive into the JSON-RPC protocol.
MCP Official Documentation: Official insights into MCP health checks.
HTTP Monitor Reference: Comprehensive API reference for HTTP monitors.
CLI Reference: Full documentation for the openstatus CLI.