Skip to content

Chronos MCP

What it is

Chronos MCP is a high-performance Model Context Protocol (MCP) server for CalDAV calendar and task management. In early 2027, it is built on FastMCP 3.1 and supports the MCP 3.1 Task Protocol, enabling frontier models like Claude 5.1, GPT-5.5/5.6, Gemini 4.0, DeepSeek-V4, and Gemma 3 to perform deep orchestration across multiple CalDAV-compliant servers including Nextcloud, iCloud, and Fastmail.

What problem it solves

It bridges the gap between autonomous AI agents and standard calendar protocols (RFC 4791, RFC 4918). Chronos allows agents to manage complex scheduling, task lists (VTODO), and journals (VJOURNAL) without needing bespoke integrations for every calendar provider, while maintaining high security through system-level keyring integration.

Where it fits in the stack

Automation & Orchestration Layer. It serves as a specialized tool for agents requiring persistent, multi-account access to temporal and task-based data, sitting between the LLM reasoning engine and the DAV storage layer.

Typical use cases

  • Multi-Account Orchestration: Coordinating events between a personal Fastmail account and a corporate Nextcloud instance.
  • Agentic Task Management: Allowing AI assistants to create, update, and prioritize VTODO tasks based on conversation context.
  • Search & Synthesis: Performing complex, ranked searches across years of calendar data to answer "When was the last time I met with X?".
  • Automated Logging: Using VJOURNAL entries to maintain an agentic work log or technical journal.

Strengths

  • Native FastMCP 3.1: Leverages the latest MCP features for improved tool discovery and type safety.
  • Advanced Search Engine: Includes relevance-ranked search with regex and fuzzy-match capabilities.
  • Keyring Security: Securely stores credentials using OS-native secret managers (Keychain, Windows Credential Locker).
  • Comprehensive VObject Support: Handles Events, Tasks, and Journals with full CRUD operations.

Limitations

  • CalDAV Only: Does not support proprietary APIs (e.g., Google Calendar, Microsoft Graph) directly.
  • No Conflict Resolution: Concurrent edits on the server-side may lead to standard CalDAV sync conflicts that the agent must handle.
  • Network Dependency: Requires a stable connection to the remote CalDAV server for real-time operations.

When to use it

  • When an agent needs to manage calendars or tasks across multiple providers simultaneously.
  • When you require a standardized MCP interface for CalDAV data.
  • When security and credential isolation are top priorities.

When not to use it

  • For Google Workspace environments (use Google Workspace CLI or the native Google MCP).
  • If your calendar provider does not support standard CalDAV (e.g., older Outlook versions).
  • For simple, non-agentic calendar access where a basic CLI or UI suffices.

Getting started

1. Installation

Chronos MCP is available via pip with optional security features: 

pip install chronos-mcp[secure]

2. Configuration

Configure accounts in ~/.chronos/accounts.yaml or via environment variables: 

# ~/.chronos/accounts.yaml
accounts:
  - name: "Home"
    url: "https://dav.example.com/remote.php/dav"
    username: "jules"
    calendars: ["work", "personal"]

3. Execution

Start the server for your MCP client (e.g., Claude Desktop, Gemma CLI): 

python -m chronos_mcp

CLI examples

# Verify configuration and server health
CHRONOS_CONFIG_PATH=/path/to/config.yaml python -m chronos_mcp --check

# List all available tools in the current MCP session
mcp list-tools --server chronos-mcp

# Migrate legacy plain-text passwords to secure keyring storage
chronos-mcp-migrate-keyring

API examples

Create a Task (VTODO)

{
  "method": "call_tool",
  "params": {
    "name": "create_task",
    "arguments": {
      "account": "Nextcloud",
      "summary": "Implement FastMCP 3.1 Routing Logic",
      "due": "2027-01-20T17:00:00Z",
      "priority": 1
    }
  }
}

Search Events

{
  "method": "call_tool",
  "params": {
    "name": "search_events",
    "arguments": {
      "query": "Project Gemma",
      "start_date": "2027-01-01",
      "end_date": "2027-01-31"
    }
  }
}

CalDAV Event Validation with Pydantic v2

This Python script parses and validates standard CalDAV event payloads retrieved by the Chronos MCP server using Pydantic v2:

import json
from datetime import datetime
from typing import List, Optional
from pydantic import BaseModel, Field, HttpUrl, ValidationError

class CalDAVAttendee(BaseModel):
    email: str = Field(..., description="Attendee email address")
    cn: Optional[str] = Field(None, description="Common name or display name")
    status: str = Field("NEEDS-ACTION", description="Participation status")

class CalDAVEvent(BaseModel):
    uid: str = Field(..., description="Unique event identifier (UID)")
    summary: str = Field(..., description="Event title or brief summary")
    description: Optional[str] = Field(None, description="Detailed description of the event")
    start: datetime = Field(..., description="Event start date and time")
    end: datetime = Field(..., description="Event end date and time")
    location: Optional[str] = Field(None, description="Physical location or conference URL")
    attendees: List[CalDAVAttendee] = Field(default_factory=list, description="List of event participants")
    url: Optional[HttpUrl] = Field(None, description="External resource URL associated with the event")

def validate_caldav_event(raw_json: str) -> Optional[CalDAVEvent]:
    try:
        data = json.loads(raw_json)
        # Validate using Pydantic v2 model_validate
        return CalDAVEvent.model_validate(data)
    except ValidationError as e:
        print(f"Validation Error: {e.json()}")
        return None
    except json.JSONDecodeError:
        print("Error: Invalid JSON.")
        return None

Sources / references

Contribution Metadata

  • Last reviewed: 2027-01-07
  • Confidence: high