Skip to content

Radicale Automation

Automated workflows and maintenance patterns for the Radicale CalDAV/CardDAV server, optimized for the July 2026 agentic ecosystem.

What it is

Radicale Automation refers to the set of scripts, n8n workflows, and Model Context Protocol (MCP) integrations used to automate calendar management, contact synchronization, and server maintenance for Radicale. In July 2026, this increasingly involves the use of autonomous agents like Gemma 3 and Claude 4.8 to perform natural language scheduling and contact deduplication.

What problem it solves

It reduces the manual effort required to manage self-hosted calendars and contacts. This includes automated backups of .ics and .vcf files, syncing contacts from external sources (like CRM or social media), and setting up automated alerts for server health. It specifically addresses the "silo" problem of self-hosted data by making it accessible to modern AI agents via the MCP 3.0 Task Protocol.

Where it fits in the stack

Category: Services / Automation. It bridges the gap between raw data storage in Radicale and actionable scheduling/contact management, acting as the integration layer for the Chronos MCP server. It sits alongside other automation tools like n8n and Home Assistant.

Typical use cases

  • Natural Language Scheduling: Using Gemma 3 to book appointments by simply describing them in chat.
  • Automated Contact Enrichment: Periodically updating contact cards with information from LinkedIn or company directories via n8n.
  • Multi-Source Synchronization: Keeping family contacts from a shared Nextcloud instance in sync with Radicale CardDAV.
  • Proactive Health Monitoring: Monitoring Radicale service availability and alerting via Telegram or Home Assistant.
  • Conflict Resolution: Using an AI agent to identify and suggest resolutions for double-booked appointments.

Strengths

  • Simple File Format: Since Radicale stores data as plain text files, automation via standard filesystem tools is straightforward.
  • REST-like API: Supports standard HTTP methods for easy integration with tools like curl and n8n.
  • MCP Compatibility: Seamlessly exposes data to agents via the Chronos MCP.
  • Idempotency: Plain-text storage makes it easy to write idempotent sync scripts that don't duplicate entries.

Limitations

  • No Native Webhooks: Relies on polling or filesystem watchers for change detection.
  • Authentication Complexity: Requires handling htpasswd or LDAP credentials in automation scripts.
  • Scaling: While fine for individuals and families, large-scale automation may hit filesystem lock contention if multiple scripts write simultaneously.

When to use it

  • To ensure your self-hosted calendar data is regularly backed up and synchronized.
  • When you need to integrate your private calendar with other automation tools like n8n or Home Assistant.
  • To enable agentic scheduling via Claude 4.8 or Gemma 3.
  • For maintaining a private, air-gapped scheduling system.

When not to use it

  • If you only have a single user and a single device, manual management might be sufficient.
  • If you require millisecond-level real-time synchronization across hundreds of concurrent users.
  • If you are already fully committed to an integrated suite like Nextcloud which handles its own internal automation.

Getting started

Prerequisites

  • A running Radicale instance.
  • Access to the Radicale storage directory (usually ~/.var/lib/radicale/collections).
  • (Optional) Chronos MCP for agentic access.

Automated Backup Script

Create a simple bash script to backup your collections:

#!/bin/bash
BACKUP_DIR="/path/to/backups/radicale_$(date +%Y%m%d)"
mkdir -p "$BACKUP_DIR"
cp -r ~/.var/lib/radicale/collections/* "$BACKUP_DIR"
tar -czf "${BACKUP_DIR}.tar.gz" "$BACKUP_DIR"
rm -rf "$BACKUP_DIR"

Hello World (n8n)

  1. Add an HTTP Request node in n8n.
  2. Set the Method to PROPFIND.
  3. URL: http://your-radicale-server:5232/user/.
  4. Authentication: Basic Auth (Radicale credentials).
  5. This node will return the list of available collections in XML format.

CLI examples

Automation often involves interacting with the filesystem or using curl.

# Verify all storage items for integrity via CLI
python3 -m radicale --verify-storage

# Use curl to create a new calendar collection automatically
curl -u user:pass -X MKCOL http://localhost:5232/user/new_calendar/

# List all files in a collection to check for recent changes
ls -ltr ~/.var/lib/radicale/collections/collection-data/user/

# Create a new collection for automated tasks via CalDAV (raw XML)
curl -u user:pass -X MKCOL \
     -H "Content-Type: text/xml" \
     -d '<?xml version="1.0" encoding="utf-8" ?><D:mkcol xmlns:D="DAV:" xmlns:C="urn:ietf:params:xml:ns:caldav"><D:set><D:prop><D:displayname>Automated Tasks</D:displayname><C:resourcetype><D:collection/><C:calendar/></C:resourcetype></D:prop></D:set></D:mkcol>' \
     "http://localhost:5232/user/automated-tasks/"

Agentic Interaction via MCP

# If using the Chronos MCP server, an agent can list events:
mcp-client chronos list-events --calendar "personal" --start "2026-07-01"

API examples

Python (Syncing Contacts)

import requests

# Example of pushing a new VCard to Radicale
url = "http://localhost:5232/user/contacts/new-contact.vcf"
vcard_data = """BEGIN:VCARD
VERSION:3.0
FN:John Doe
N:Doe;John;;;
EMAIL;TYPE=INTERNET:john.doe@example.com
END:VCARD"""

response = requests.put(
    url,
    data=vcard_data,
    auth=("user", "pass"),
    headers={"Content-Type": "text/vcard"}
)
print(f"Status Code: {response.status_code}")

curl (Exporting Calendar)

# Download a full calendar as a single .ics file for external processing
curl -u user:pass "http://localhost:5232/user/calendar/" -o my_calendar.ics

Sources / References

  • https://radicale.org/v3.html
  • https://docs.n8n.io/integrations/builtin/core-nodes/n8n-nodes-base.httprequest/
  • https://agentskills.io/spec/chronos-caldav/

Contribution Metadata

  • Last reviewed: 2026-07-21
  • Confidence: high