Cronlytic

What is Cronlytic MCP Server?

The Cronlytic MCP Server is a comprehensive Model Context Protocol (MCP) server designed to enable Large Language Models (LLMs) and AI agents to communicate and interact with the Cronlytic API. This integration allows LLMs to perform CRUD (Create, Read, Update, Delete) operations for serverless cron jobs seamlessly. It acts as a bridge, translating LLM requests into actions on the Cronlytic platform, making cron job management accessible through AI applications like Claude Desktop.

How to use Cronlytic MCP Server?

To use the Cronlytic MCP Server, you first need to install it. Prerequisites include Python 3.8 or higher and a Cronlytic account with API access. You can install it by cloning the repository and running the setup_dev_env.sh script for a quick setup, or manually setting up a virtual environment and installing dependencies from requirements.txt.

Configuration involves providing your Cronlytic API credentials, which can be done via environment variables (recommended), a configuration file (cronlytic_config.json), or command-line arguments. Once configured, you can run the server using python -m cronlytic_mcp_server.server. For integration with applications like Claude Desktop, you can add specific configurations to your claude_desktop_config.json file, specifying the command, arguments, and environment variables for the MCP server.

Key Features of Cronlytic MCP Server

• Health Check: Tests connectivity and authentication with the Cronlytic API.
• Job Management: Supports creating, reading, updating, and deleting cron jobs.
• Job Control: Allows pausing, resuming, and monitoring job execution.
• Logs & Monitoring: Provides access to execution logs and performance metrics.
• Smart Prompts: Includes 18 comprehensive prompts for guided assistance.
• Resources: Offers dynamic job resources and cron templates.
• Performance: Built-in monitoring and optimization capabilities.
• Comprehensive Testing: Achieved 88/88 passing tests, indicating high reliability.
• Production Ready: Designed for multi-platform deployment.
• Robust Error Handling: Provides clear guidance for authentication, connection, validation, and API errors, with automatic retry for rate limiting.
• Structured Logging: Offers detailed logging at multiple levels for debugging and monitoring.

Use Cases of Cronlytic MCP Server

• AI-driven Cron Job Management: Allows AI agents and LLMs to directly manage serverless cron jobs, automating scheduling and task execution.
• Integration with LLM Applications: Enables seamless integration with LLM applications like Claude Desktop for natural language control over cron jobs.
• Automated Task Scheduling: Facilitates the creation, modification, and deletion of scheduled tasks through conversational AI interfaces.
• Monitoring and Troubleshooting: Provides AI agents with the ability to retrieve job logs and monitor performance, aiding in automated troubleshooting.
• Developer Productivity: Simplifies cron job management for developers by leveraging AI for common operations, reducing manual intervention.

FAQ from Cronlytic MCP Server

Q: What are the prerequisites for installing Cronlytic MCP Server? A: You need Python 3.8 or higher and a Cronlytic account with API access.

Q: How do I provide my Cronlytic API credentials? A: You can use environment variables (recommended), a configuration file (cronlytic_config.json), or command-line arguments.

Q: Can I integrate Cronlytic MCP Server with Claude Desktop? A: Yes, you can integrate it by configuring your claude_desktop_config.json file with the server's command, arguments, and environment variables.

Q: What kind of error handling does the server provide? A: It offers comprehensive error handling for authentication, connection, validation, and API errors, including automatic retries for rate limiting.

Q: What are the future plans for Cronlytic MCP Server? A: The roadmap includes further development in basic CRUD operations, advanced job management, resources implementation, prompts & UX enhancements, and comprehensive testing & documentation.

Cronlytic MCP Server

🎉 PROJECT COMPLETED - PRODUCTION READY 🎉

A comprehensive Model Context Protocol (MCP) server that integrates with the Cronlytic API to provide seamless cron job management through LLM applications like Claude Desktop.

Final Status: ✅ All 6 phases complete | 88/88 tests passing | Production documentation ready

Overview

The Cronlytic MCP Server enables AI agents and LLM applications to:

• 🔍 Health Check: Test connectivity and authentication with the Cronlytic API ✅
• 📊 Job Management: Create, read, update, and delete cron jobs ✅
• ⏯️ Job Control: Pause, resume, and monitor job execution ✅
• 📝 Logs & Monitoring: Access execution logs and performance metrics ✅
• 🤖 Smart Prompts: 18 comprehensive prompts for guided assistance ✅
• 📚 Resources: Dynamic job resources and cron templates ✅
• ⚡ Performance: Built-in monitoring and optimization ✅

🏆 Project Status: ALL PHASES COMPLETED ✅

🎯 Final Achievement Summary:

• ✅ Phase 1: Core infrastructure and authentication
• ✅ Phase 2: Basic CRUD operations (13 tests)
• ✅ Phase 3: Advanced job management (22 tests)
• ✅ Phase 4: Resources implementation (14 tests)
• ✅ Phase 5: Prompts & UX (39 tests)
• ✅ Phase 6: Testing & documentation (performance monitoring)

📊 Key Metrics:

• 88/88 Tests Passing (100% success rate)
• 18 Interactive Prompts (225% of original scope)
• 9 Comprehensive Tools (Full job lifecycle)
• Complete Documentation Suite (8 detailed guides)
• Production Ready (Multi-platform deployment support)

Installation

Prerequisites

• Python 3.8 or higher
• Cronlytic account with API access

Install from Source

Quick Setup (Recommended)

# Clone the repository
git clone https://github.com/Cronlytic/cronlytic-mcp-server.git
cd cronlytic-mcp-server

# Run the setup script (creates venv and installs everything)
./setup_dev_env.sh

# Activate the virtual environment
source venv/bin/activate

Manual Setup

# Clone the repository
git clone https://github.com/Cronlytic/cronlytic-mcp-server.git
cd cronlytic-mcp-server

# Create virtual environment
python3 -m venv venv
source venv/bin/activate

# Upgrade pip
pip install --upgrade pip

# Install dependencies
pip install -r requirements.txt

# Install development dependencies (optional)
pip install -r requirements-dev.txt

# Install in development mode
pip install -e .

Configuration

The server needs your Cronlytic API credentials to function. You can provide these in several ways:

Method 1: Environment Variables (Recommended)

export CRONLYTIC_API_KEY="your_api_key_here"
export CRONLYTIC_USER_ID="your_user_id_here"

Method 2: Configuration File

Create a configuration file at one of these locations:

• ./cronlytic_config.json (current directory)
• ~/.cronlytic/config.json (user home directory)
• /etc/cronlytic/config.json (system-wide)

{
  "api_key": "your_cronlytic_api_key_here",
  "user_id": "your_cronlytic_user_id_here",
  "base_url": "https://api.cronlytic.com/prog",
  "timeout": 30,
  "max_retries": 3,
  "retry_delay": 1.0
}

Method 3: Command Line Arguments

python -m cronlytic_mcp_server.server --api-key "your_key" --user-id "your_id"

Getting API Keys

1. Log into your Cronlytic dashboard
2. Navigate to "API Keys" section
3. Click "Generate New API Key"
4. Copy your API key and User ID

Usage

Running the Server

# Basic usage (reads from environment variables or config file)
python -m cronlytic_mcp_server.server

# With command line arguments
python -m cronlytic_mcp_server.server --api-key "your_key" --user-id "your_id"

# With debug logging
python -m cronlytic_mcp_server.server --debug

# With custom config file
python -m cronlytic_mcp_server.server --config /path/to/config.json

Available Tools (Phase 1)

Health Check

Test connectivity and authentication with the Cronlytic API:

# The health_check tool requires no parameters
# It will test:
# - API connectivity
# - Authentication validity
# - Response times
# - Basic functionality

Example Output:

# Cronlytic API Health Check

**Status:** ✅ Cronlytic API connection is healthy and working correctly
**Timestamp:** 2025-01-27T10:30:00Z
**Response Time:** 150 ms

## Connection Details
- **Base URL:** https://api.cronlytic.com/prog
- **Connectivity:** ✅
- **Authentication:** ✅

## Job Information
- **Job Count:** 3
- **Can List Jobs:** ✅

## Performance
- **Performance Rating:** Good

## Recommendations
- 💡 Found 3 job(s). All systems appear to be working correctly.

Claude Desktop Integration

To use with Claude Desktop, add this to your claude_desktop_config.json:

{
  "mcpServers": {
    "cronlytic": {
      "command": "python",
      "args": ["-m", "cronlytic_mcp_server.server"],
      "env": {
        "CRONLYTIC_API_KEY": "your_api_key_here",
        "CRONLYTIC_USER_ID": "your_user_id_here"
      }
    }
  }
}

To run virtual environment of python

{
  "mcpServers": {
          "cronlytic": {
        "command": "python",
        "args": ["-m", "src.server"],
        "cwd": "PATH/cronlytic-mcp-server",
        "env": {
          "VIRTUAL_ENV": "PATH/cronlytic-mcp-server/.venv",
          "PATH": "PATH/cronlytic-mcp-server/.venv/bin:${PATH}",
          "CRONLYTIC_API_KEY": "your_api_key_here",
          "CRONLYTIC_USER_ID": "your_user_id_here"
        }
      }
  }
}

Development

Project Structure

cronlytic-mcp-server/
├── src/
│   ├── __init__.py              # Package initialization
│   ├── server.py                # Main MCP server implementation
│   ├── cronlytic_client.py      # Cronlytic API client wrapper
│   ├── tools/                   # Tool implementations
│   │   ├── __init__.py
│   │   └── health_check.py      # Health check tool
│   ├── resources/               # Resource implementations (Phase 4)
│   ├── prompts/                 # Prompt implementations (Phase 5)
│   └── utils/                   # Utility modules
│       ├── __init__.py
│       ├── auth.py              # Authentication handling
│       ├── errors.py            # Custom error classes
│       └── validation.py        # Input validation
├── tests/                       # Test files (Phase 6)
├── config/
│   └── example_config.json      # Example configuration
├── requirements.txt
├── pyproject.toml
└── README.md

Running in Development Mode

# Activate virtual environment (if not already active)
source venv/bin/activate

# Install in development mode (if not already done)
pip install -e .

# Set environment variables for testing
export CRONLYTIC_API_KEY="your_test_key"
export CRONLYTIC_USER_ID="your_test_user_id"

# Run with debug logging
python -m cronlytic_mcp_server.server --debug

# Run validation tests
python validate_phase1.py

# Format code (if you have development dependencies)
black src/
ruff check src/

# Type checking
mypy src/

Testing with MCP Inspector

# Install MCP Inspector
npm install -g @modelcontextprotocol/inspector

# Test the server
mcp-inspector python -m cronlytic_mcp_server.server

Error Handling

The server provides comprehensive error handling:

• Authentication Errors: Clear guidance on credential issues
• Connection Errors: Network and connectivity diagnostics
• Validation Errors: Detailed field-by-field validation messages
• API Errors: Proper error codes and user-friendly messages
• Rate Limiting: Automatic retry with exponential backoff

Logging

Structured logging is provided at multiple levels:

# Normal operation
2025-01-27 10:30:00 - cronlytic_mcp_server.server - INFO - Cronlytic MCP Server initialized

# Debug mode
python -m cronlytic_mcp_server.server --debug

Roadmap

Phase 2: Basic CRUD Operations (Next)

• create_job - Create new cron jobs
• list_jobs - List all user jobs
• get_job - Get specific job details
• update_job - Update existing jobs
• delete_job - Delete jobs permanently

Phase 3: Advanced Job Management

• pause_job - Pause job execution
• resume_job - Resume paused jobs
• get_job_logs - Retrieve execution logs

Phase 4: Resources Implementation

• Dynamic job resources
• Cron template library
• Real-time resource updates

Phase 5: Prompts & UX

• Interactive job creation flows
• Monitoring and troubleshooting guidance
• User experience optimization

Phase 6: Testing & Documentation

• Comprehensive test suite
• Performance optimization
• Complete documentation

Contributing

This project follows a structured development approach with clearly defined phases. Each phase builds upon the previous one to ensure stability and maintainability.

1. Fork the repository
2. Create a feature branch
3. Make your changes
4. Add tests (Phase 6)
5. Submit a pull request

License

MIT License - see LICENSE file for details.

Support

• Documentation: See docs/ directory for detailed specifications
• Issues: Report bugs and feature requests on GitHub
• API Reference: Check docs/cronlytic-API-specification.md

Related Projects

• Cronlytic - The cron job monitoring service
• Model Context Protocol - The open protocol for AI integration
• Claude Desktop - AI assistant with MCP support

---

Current Version: 0.1.0 Last Updated: Jun 2025