# iCalendar RRULE Iterator MCP for AI Agents MCP

> iCalendar RRULE Iterator turns complex recurrence strings into predictable lists of dates. It handles the heavy lifting of expanding rules, making sure your calendar logic stays accurate across timezones and daylight saving changes. Perfect for anyone building scheduling automation or managing recurring event sequences without manual date math.

## Overview
- **Category:** productivity
- **Price:** Free
- **Endpoint:** https://edge.vinkius.com/vk_preview_4JyXG2816vETvNwr9sU661ffjKPwyowL5JhwwpVu/mcp
- **Tags:** icalendar, rrule, scheduling, automation, date-math

## Description

Managing recurring events is a nightmare when you have to account for leap years, varying month lengths, and sudden shifts in daylight saving time. If your code relies on local system clocks, your calendar will eventually drift and break. This MCP solves that by using UTC-based integer math to expand any iCalendar recurrence rule into an exact, chronological sequence of timestamps. You can use it to inspect exactly how a rule is built or to generate a full list of upcoming occurrences from a specific start date. It's like having a specialized engine for calendar logic that you just plug into your agent. When you connect this to the Vinkius catalog, you get a reliable way to check rule syntax and break down complex patterns without writing a single line of custom parsing logic yourself.

## Tools

### audit_rule_syntax
Checks an RRULE string for structural errors to prevent broken schedules.

### decompose_rrule
Breaks a rule down into its specific parts for easier inspection.

### calculate_event_dates
Generates a precise list of upcoming event timestamps from a starting point.

## Prompt Examples

**Prompt:** 
```
What are the next three dates for a weekly event starting on 2024-01-01 with an interval of 2?
```

**Response:** 
```
The occurrences for RRULE:FREQ=WEEKLY;INTERVAL=2 starting from 2024-01-01 are:

* **2024-01-01**
* **2024-01-15**
* **2024-01-29**
```

**Prompt:** 
```
Check if this RRULE is valid: FREQ=MONTHLY;INTERVAL=1
```

**Response:** 
```
The syntax for the provided rule is valid and contains a properly defined frequency.
```

**Prompt:** 
```
Break down this rule: FREQ=DAILY;COUNT=5
```

**Response:** 
```
The decomposed components are:

* **FREQ**: DAILY
* **COUNT**: 5
```

## Capabilities

### Expand recurrence rules
Turn complex RRULE strings into a clear list of future event dates.

### Inspect rule components
Break down any rule into its individual parts like frequency and interval.

### Validate syntax
Check if an RRULE string is structurally sound before you use it in your application.

### Handle timezone shifts
Make sure all calculated dates remain accurate regardless of local DST changes.

## Use Cases

### Validating recurring meeting schedules
A developer needs to ensure a new monthly meeting rule is valid; they ask their agent, which checks the string for correctness.

### Generating monthly report triggers
An ops engineer wants to know every Tuesday for the next month; the agent generates a list of all upcoming dates.

### Debugging broken calendar invites
A user sees a weird gap in their schedule and asks the agent to break down the rule to see if an interval is wrong.

## Benefits

- Eliminate DST errors by using UTC-based math for every calculated date.
- Catch typos early by checking rule integrity before deployment.
- Simplify complex scheduling logic by breaking rules down into readable parts.
- Automate event generation by pulling exact lists of dates automatically.
- Reduce manual debugging of calendar edge cases in your automation workflows.

## How It Works

The bottom line is you get mathematically certain event sequences without manual parsing.

1. Connect the MCP to your preferred AI client via Vinkius.
2. Provide an RRULE string or a specific start date to your agent.
3. Receive a precise, chronological list of timestamps or a breakdown of the rule's parts.

## Frequently Asked Questions

**How can I check if my calendar rule is written correctly with iCalendar RRULE Iterator?**
You can use the tool to audit your string and ensure it follows the proper structural syntax before you deploy it in your automation.

**Can iCalendar RRULE Iterator handle daylight saving time changes?**
Yes, it uses UTC-based math to ensure that all calculated event sequences remain identical regardless of any local timezone or DST transitions.

**How do I get a list of all future dates for a recurring meeting using iCalendar RRULE Iterator?**
You simply provide the rule and a start date to your agent, and it will generate a precise, chronological list of every occurrence.

**Is it possible to see the individual parts of a complex recurrence rule with iCalendar RRULE Iterator?**
Yes, you can break any rule down into its specific components like frequency and interval to understand exactly how it's structured.

**Will iCalendar RRULE Iterator work for bi-weekly or monthly schedules?**
Absolutely, it is designed to expand any standard iCalendar recurrence rule, no matter the frequency or interval you specify.

**How does the engine handle timezone changes?**
The engine uses UTC-based integer math via the V8 Date object, ensuring that all calculations are deterministic and unaffected by local timezone shifts or daylight saving transitions.

**Can I verify if my RRULE string is valid before processing it?**
Yes, you can use the `audit_rule_syntax` tool to check for structural errors like missing FREQ properties or malformed intervals.

**What parameters can I extract from a rule?**
By using `decompose_rrule`, you can extract key-value pairs such as FREQ, INTERVAL, COUNT, and UNTIL to understand the rule's configuration.