How We Built an MCP Server to Handle Your Uptime Monitoring

A behind-the-scenes look at how AVIMBU connected uptime-agent.io to AI assistants through the Model Context Protocol

At AVIMBU, we're constantly exploring ways to make our tools more accessible and powerful. Today, we're excited to share how we've bridged the gap between our uptime-agent.io monitoring service and AI assistants like Claude through the Model Context Protocol (MCP). This integration allows you to manage your website and API monitoring through natural language conversations with your AI assistant.

What is the Model Context Protocol (MCP)?

The Model Context Protocol (MCP) is an emerging standard that enables AI assistants to interact with external tools and services. Think of it as a universal translator that allows AI models to access real-time data and perform actions in the real world while maintaining a conversation with you.

MCP servers act as intermediaries between AI assistants and external services. They define a set of functions (tools) that the AI can call, handle authentication securely, and translate between the AI's requests and the service's API requirements.

MCP Architecture Diagram

Why We Built an MCP Server for Uptime Monitoring

Website and API downtime can be costly and damaging to your business reputation. Our uptime-agent.io service already provides robust monitoring, but we wanted to make it even more accessible by allowing you to:

Check monitoring status through conversation - Simply ask your AI assistant about your website's uptime
Analyze incidents naturally - Get insights about outages without navigating dashboards
Create new monitors on the fly - Set up monitoring for new endpoints through simple conversation
Receive contextual recommendations - Get AI-powered suggestions based on your monitoring data

By building an MCP server, we've enabled these capabilities while maintaining enterprise-grade security for your monitoring infrastructure.

Technical Deep Dive: How Our MCP Server Works

Our MCP server is built using Node.js and TypeScript, leveraging the official MCP SDK. Here's how it works:

Server Initialization: The server registers with the MCP protocol and declares its capabilities
Tool Registration: We define a set of functions (tools) that AI assistants can call
Authentication: Your API key is securely stored and used for all API calls
Request Handling: When an AI assistant invokes a tool, our server processes the request and calls the uptime-agent.io API
Response Formatting: Results are formatted and returned to the AI assistant in a way it can understand

The core tools we've implemented include:

listMonitors - Retrieves all your active monitoring endpoints
getMonitor - Gets detailed information about a specific monitor
createMonitor - Sets up a new endpoint to monitor
listIncidents - Views all detected downtime incidents
getIncident - Gets detailed information about a specific incident
listIncidentsByMonitor - Shows all incidents for a particular endpoint
createAnonymousTracking - Creates public tracking without authentication

Each of these tools maps directly to our uptime-agent.io API, allowing seamless interaction through your AI assistant.

Setting Up the MCP Server

Want to try it yourself? Here's how to set up our MCP server with Claude:

Prerequisites

An active uptime-agent.io account
Your uptime-agent.io API key (found in your account dashboard under Settings → API Keys)
Node.js 18 or higher installed

Option 1: Quick Install via NPM (Recommended)

The fastest way to get started is with our setup command:

bash

1npx uptime-agent-mcp setup

This command will:

Install the MCP server
Configure it for use with Claude Desktop
Prompt you for your uptime-agent.io API key
Set up all necessary configurations automatically

Option 2: Install via Smithery.ai

If you prefer using Smithery.ai:

Create an account at smithery.ai
Get your personal key from your Smithery account
Run the following command:

bash

1npx -y @smithery/cli@latest install @AVIMBU/uptime_agent_mcp --client claude --key <personal_key>

Replace <personal_key> with your actual Smithery personal key.

Option 3: Manual Configuration in Claude Desktop

If you prefer to manually configure Claude Desktop:

Open Claude Desktop on your computer
Navigate to Settings (gear icon) → Advanced Settings
Find the "MCP Servers" section and click "Add New Server"
Enter the following configuration:

json

1{
2  "mcpServers": {
3    "uptime-agent": {
4      "command": "npx",
5      "args": [
6        "-y",
7        "uptime-agent-mcp"
8      ],
9      "env": {
10        "UPTIME_API_KEY": "your-api-key-here"
11      }
12    }
13  }
14}

Replace your-api-key-here with your actual uptime-agent.io API key
Save the configuration

Step 4: Test the Connection

Once configured, you can test the connection by asking Claude about your monitors:

"Claude, can you list all my active uptime monitors?"

Claude should connect to the MCP server, which will authenticate with uptime-agent.io and return your monitor information. The response will look something like this:

"I've connected to your uptime monitoring system. You currently have 5 active monitors:

Production API (https://api.example.com/health) - Status: UP

Marketing Website (https://example.com) - Status: UP

Customer Portal (https://portal.example.com) - Status: UP

Payment Gateway (https://payments.example.com/status) - Status: WARNING

Analytics Dashboard (https://analytics.example.com) - Status: DOWN

Would you like more details about any specific monitor or the current incidents?"

Using the MCP Server in Your Daily Workflow

Now that your MCP server is set up, here are some examples of how you can use it in your daily workflow:

Checking Monitor Status

Ask about the overall status of your monitoring:

"Give me a summary of all my monitoring endpoints."

Creating New Monitors

Set up monitoring for new endpoints:

"Please create a new monitor for our blog at https://blog.example.com. Check it every 5 minutes."

Analyzing Downtime

Get insights about recent incidents:

"What incidents occurred last week and what was the average response time before resolution?"

Investigating Specific Issues

Dive deeper into particular problems:

"Tell me more about the incident on our payment gateway from yesterday."

Security Considerations

We take security seriously at AVIMBU. Here's how we protect your data:

API Key Security: Your API key is stored locally and only transmitted over HTTPS to authenticate with our API
Limited Permissions: The MCP server can only access endpoints authorized by your API key
No Data Storage: The server doesn't store any of your monitoring data locally
Secure Communications: All API calls use HTTPS encryption

Future Vision: The Autonomous Uptime Monitoring Agent

While our MCP server integration represents a significant step forward, it's just the beginning of our vision for uptime-agent.io. We're working toward creating a fully autonomous AI Uptime Monitoring Agent that transcends traditional monitoring to become an active guardian of your systems.

Our Roadmap to Autonomous System Management

Natural Language Analytics: Ask questions about your uptime patterns in plain English
Proactive Notifications: Have Claude alert you when incidents occur
Slack Integration: Connect your Slack channels for team notifications
Multi-Account Support: Manage multiple uptime-agent.io accounts from a single MCP server

But our ultimate vision goes much further:

The Agentic Web Approach to System Reliability

We envision uptime-agent.io evolving into a fully autonomous agent capable of:

Automatic Deployment Integration: Direct communication with your Docker containers, Kubernetes clusters, and PaaS solutions
Intelligent Log Analysis: Parsing through system logs to identify root causes without human intervention
Autonomous Recovery Actions: Automatically restarting services, scaling resources, or implementing fixes when issues are detected
Predictive Failure Prevention: Identifying patterns that precede outages and taking preventative action
Continuous Learning: Improving its troubleshooting capabilities through each incident it resolves

Our goal is ambitious but clear: to guarantee you a continuously operating system with zero manual intervention required. Imagine a world where your infrastructure essentially manages itself—where downtime is automatically remediated before it impacts your users, and where the technical details of troubleshooting are handled without your team needing to be on call 24/7.

This isn't just monitoring reimagined; it's a fundamental shift in how we approach system reliability—moving from reactive to proactive, from manual to autonomous, and from information to action.

Conclusion

By building an MCP server for uptime-agent.io, we've made website and API monitoring more accessible and intuitive than ever before. Now you can check your monitoring status, create new monitors, and analyze incidents through natural conversation with Claude or other AI assistants.

This integration is just the first step in our journey toward truly autonomous system management. We believe the combination of reliable monitoring with agentic AI capabilities will revolutionize how teams maintain their infrastructure, dramatically reducing downtime while freeing up valuable engineering resources.

As we continue developing uptime-agent.io, we invite you to join us in this journey. Your feedback and real-world usage patterns will help us refine our autonomous agent and bring the vision of zero-touch system reliability to life.

Ready to get started? Sign up for uptime-agent.io today and take the first step toward AI-powered, autonomous infrastructure management.

Have questions about our MCP server or uptime-agent.io? Contact us at hello@avimbu.com or visit our documentation.