Skip to main content
Glama
anastasiakrause

Weekly Planning Assistant MCP

Weekly Planning Assistant MCP

An intelligent MCP server that turns your Google Calendar into actionable weekly insights through natural conversation.

MCP Python License

What It Does

Ask Claude natural questions about your schedule and get intelligent analysis:

  • "What does my week look like?" → Day-by-day breakdown with meeting hours, office days, and free time

  • "When should I book boxing classes?" → Ranked workout time suggestions based on your actual schedule

  • "Which days am I going to the office?" → Office day detection with commute warnings

  • "Do I have any scheduling problems?" → Identifies conflicts, missing lunch breaks, and marathon meeting blocks

Related MCP server: Summary MCP

How It Works

graph LR
    A[You ask Claude] --> B[Weekly Planner MCP]
    B --> C[Google Calendar MCP]
    C --> D[Your Google Calendar]
    D --> C
    C --> B
    B --> A

This server demonstrates MCP chaining - it acts as both a server (to Claude) and a client (to Google Calendar MCP), providing domain-specific intelligence on top of raw calendar data.

Features

🗓️ Week Analysis

  • Office vs. WFH day detection

  • Total meeting hours per day

  • Free time gaps (>1 hour)

  • Back-to-back meeting blocks

  • Busiest/lightest day identification

⚠️ Danger Zone Detection

  • Missing lunch breaks (meetings 12-2pm)

  • Marathon meetings (3+ hours straight)

  • Days with zero free time

  • Calendar conflicts and overlaps

🏃 Workout Planning

  • Quality-scored time slot suggestions

  • Preference-based filtering (morning/lunch/evening)

  • Commute-aware recommendations

  • Duration-based slot matching

🚗 Commute Planning

  • Office day detection via keywords

  • Earliest arrival time calculation

  • Early morning gym warnings

  • Multi-calendar support

Installation

Prerequisites

  • Python 3.11+ - Download

  • Node.js - Download (for Google Calendar MCP)

  • Claude Desktop - Download

  • Google Account with Calendar access

1. Clone and Install

# Clone the repository
git clone https://github.com/yourusername/weekly-planner-mcp.git
cd weekly-planner-mcp

# Install uv (Python package manager)
curl -LsSf https://astral.sh/uv/install.sh | sh
source $HOME/.local/bin/env

# Install dependencies
uv sync

2. Configure Settings

# Copy example configuration
cp config.example.json config.json

# Edit with your preferences
nano config.json

Example config.json:

{
  "calendar_ids": ["primary"],
  "office_keywords": ["office", "HQ"],
  "work_hours": {
    "start": "09:00",
    "end": "18:00"
  },
  "preferred_workout_times": ["morning", "lunch"],
  "min_workout_duration": 60
}

3. Set Up Google Calendar OAuth

A. Create Google Cloud Project

  1. Go to Google Cloud Console

  2. Click "New Project"

  3. Name it (e.g., "Weekly Planner")

  4. Click "Create"

B. Enable Calendar API

  1. Search for "Google Calendar API"

  2. Click "Enable"

  1. Go to "APIs & Services""OAuth consent screen"

  2. Select "External" user type

  3. Fill in app name and your email

  4. Click "Save and Continue" through all steps

  5. Under "Test users", click "+ ADD USERS"

  6. Add your Gmail address

D. Create OAuth Credentials

  1. Go to "Credentials""Create Credentials""OAuth client ID"

  2. Application type: "Desktop app" ⚠️ (NOT Web application!)

  3. Name: "Weekly Planner Desktop"

  4. Click "Create" and "Download JSON"

E. Save and Authenticate

# Save credentials
mkdir -p ~/.config/google-calendar-mcp
mv ~/Downloads/client_secret_*.json ~/.config/google-calendar-mcp/gcp-oauth.keys.json

# Authenticate
export GOOGLE_OAUTH_CREDENTIALS="$HOME/.config/google-calendar-mcp/gcp-oauth.keys.json"
npx -y @cocal/google-calendar-mcp auth

Your browser will open - sign in and grant calendar permissions.

4. Add to Claude Desktop

Edit ~/Library/Application Support/Claude/claude_desktop_config.json:

{
  "mcpServers": {
    "weekly-planner": {
      "command": "/Users/yourusername/.local/bin/uv",
      "args": [
        "--directory",
        "/absolute/path/to/weekly-planner-mcp",
        "run",
        "python",
        "-m",
        "weekly_planner",
        "--stdio"
      ],
      "env": {
        "GOOGLE_OAUTH_CREDENTIALS": "/Users/yourusername/.config/google-calendar-mcp/gcp-oauth.keys.json"
      }
    }
  }
}

Replace:

  • /Users/yourusername/ with your actual home directory (run echo $HOME)

  • /absolute/path/to/weekly-planner-mcp with full path to this project

5. Restart Claude Desktop

Quit Claude Desktop (⌘+Q) and reopen. Test with:

"What does my week look like?"

Configuration

Basic Settings

Edit config.json to customize behavior:

{
  "calendar_ids": ["primary"],           // Which calendars to analyze
  "office_keywords": ["office", "HQ"],   // Keywords for office detection
  "work_hours": {
    "start": "09:00",
    "end": "18:00"
  },
  "preferred_workout_times": ["morning", "lunch", "evening"],
  "min_workout_duration": 60             // Minutes
}

Adding Multiple Calendars

To include work calendars or imported calendars, first list your available calendars, then add their IDs to config.json.

See the full command in the Development section below for listing calendars.

Architecture

Project Structure

weekly-planner-mcp/
├── src/weekly_planner/
│   ├── server.py          # FastMCP server with 4 tools
│   ├── gcal_client.py     # Google Calendar MCP client
│   ├── analysis.py        # Core scheduling analysis logic
│   ├── models.py          # Pydantic models for structured output
│   └── config.py          # Configuration management
├── config.json            # Your configuration
├── config.example.json    # Example configuration
└── pyproject.toml         # Dependencies

Tools Provided

  1. analyze_week - Comprehensive weekly overview with day-by-day breakdown

  2. find_danger_zones - Identifies scheduling problems and conflicts

  3. suggest_workout_slots - Intelligent workout time suggestions with quality scoring

  4. check_commute_requirements - Office day detection with commute planning

All tools return structured Pydantic models for type-safe, validated responses.

Example Usage

Week Overview:

You: What does my week look like?

Claude: Here's your week breakdown:

Monday (4.5h meetings)
• Office day detected
• Free slots: 9:00-10:00, 14:00-16:00
• 3-hour back-to-back block in morning

Tuesday (2h meetings)
• Lightest day this week
• Large gap: 11:00-17:00

Workout Planning:

You: When should I book a 60-minute workout this week?

Claude: Best times ranked by quality:

1. Tuesday 11:00-12:00 (Score: 8.5/10)
   • Long gap available
   • Lunch time slot
   • Not near office days

2. Friday 18:30-19:30 (Score: 7.8/10)
   • Evening slot
   • After work hours

Office Days:

You: Which days am I going to the office?

Claude: You have 2 office days this week:

• Monday: Office all day (earliest: 9:30am)
  ⚠️ Early start - avoid morning gym

• Thursday: Afternoon in office (earliest: 2:00pm)
  ✓ Morning free for workout

Development

List Available Calendars

cd /path/to/weekly-planner-mcp
export GOOGLE_OAUTH_CREDENTIALS="$HOME/.config/google-calendar-mcp/gcp-oauth.keys.json"

uv run python -c "
import asyncio, os
os.environ['GOOGLE_OAUTH_CREDENTIALS'] = os.path.expanduser('~/.config/google-calendar-mcp/gcp-oauth.keys.json')
from mcp import ClientSession, StdioServerParameters
from mcp.client.stdio import stdio_client

async def list_cals():
    params = StdioServerParameters('npx', ['-y', '@cocal/google-calendar-mcp', 'start'], env=os.environ.copy())
    async with stdio_client(params) as (r, w):
        async with ClientSession(r, w) as s:
            await s.initialize()
            result = await s.call_tool('list-calendars', {})
            import json
            for cal in json.loads(result.content[0].text)['calendars']:
                print(f'{cal[\"summary\"]}: {cal[\"id\"]}')
asyncio.run(list_cals())
"

Add calendar IDs to config.json under calendar_ids.

Check Logs

# Claude Desktop logs
tail -f ~/Library/Logs/Claude/mcp-server-weekly-planner.log

# Re-authenticate if needed
npx -y @cocal/google-calendar-mcp auth

Troubleshooting

"OAuth credentials not found"

  • Verify: ls -la ~/.config/google-calendar-mcp/gcp-oauth.keys.json

  • Ensure GOOGLE_OAUTH_CREDENTIALS is set in Claude Desktop config

"No events returned"

  • Re-authenticate: npx -y @cocal/google-calendar-mcp auth

  • Verify calendar IDs in config.json

  • Check logs: tail -f ~/Library/Logs/Claude/mcp-server-weekly-planner.log

"Access denied" during OAuth

  • Add yourself as a test user in Google Cloud Console

  • Use the exact Gmail address you added

  • Application type must be "Desktop app" not "Web application"

"Token expired"

export GOOGLE_OAUTH_CREDENTIALS="$HOME/.config/google-calendar-mcp/gcp-oauth.keys.json"
npx -y @cocal/google-calendar-mcp auth

What This Demonstrates

This project showcases key MCP concepts:

  • MCP Chaining - One MCP server calling another MCP server

  • Structured Output - Type-safe responses using Pydantic models

  • Domain Abstractions - High-level analysis tools built on generic calendar API

  • Configuration Management - File-based and environment variable configuration

  • FastMCP Usage - Modern MCP server implementation with decorators

  • OAuth Integration - Secure Google Calendar API authentication

Available Tools

4 tools
analyze_weekA

Get a comprehensive overview of the upcoming week.

Analyzes calendar events to provide day-by-day breakdown with office days,
meeting hours, gaps, and back-to-back meeting blocks.

Args:
    start_date: Week start date (YYYY-MM-DD). Defaults to next Monday.
    calendar_ids: List of calendar IDs to analyze. Defaults to ["primary"].

Returns:
    Complete weekly analysis with per-day breakdowns and summary statistics.
ParametersJSON Schema
NameRequiredDescriptionDefault
start_dateNo
calendar_idsNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
daysYesPer-day breakdown
end_dateYesWeek end date (YYYY-MM-DD)
start_dateYesWeek start date (YYYY-MM-DD)
busiest_dayYesDay with most meeting hours
lightest_dayYesDay with least meeting hours
office_day_countYesNumber of office days
total_scheduled_hoursYesTotal meeting hours for the week

TDQS

A3.6/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It discloses the analysis dimensions and return scope, but says nothing about permissions, whether it falls back gracefully when calendars are empty, or any rate/volume constraints. For a read-only analysis tool this is adequate but leaves gaps.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loaded with a one-line summary, then structured Args/Returns sections with no filler. Every sentence carries information; the only minor redundancy is restating return contents given a dedicated output schema exists.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

With an output schema present, the description needn't detail return shapes, yet it summarizes them helpfully. The two optional parameters are fully covered, and the read-only analysis nature is clear; missing only explicit guidance on when to prefer it over siblings.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate, and it does: it documents both parameters with their expected format (YYYY-MM-DD), their defaults (next Monday, ['primary']), and their meaning. This meaningfully exceeds the bare schema, though it adds no validation or edge-case notes.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb and resource ('analyze' + 'week' of calendar events) and enumerates the concrete outputs: day-by-day breakdown, office days, meeting hours, gaps, back-to-back blocks. It is clearly distinct from the sibling tools (danger zones, workout slots, commute), though it never explicitly names or contrasts them.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied by 'upcoming week' and the default of next Monday, giving an agent a sense of the intended scope. However, there is no explicit when-to-use, when-not-to-use, or comparison to any alternative tool, so the agent must infer the trigger conditions.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

check_commute_requirementsA

Identify which days require office commute.

Analyzes calendar events to detect office days and provides:
- Which days require office presence
- Earliest time needed at office
- Warnings about early morning commitments

Args:
    start_date: Start date (YYYY-MM-DD)
    end_date: End date (YYYY-MM-DD)
    office_indicators: Keywords indicating office presence. Defaults to config.
    calendar_ids: List of calendar IDs. Defaults to ["primary"].

Returns:
    List of office days with commute information and warnings.
ParametersJSON Schema
NameRequiredDescriptionDefault
end_dateYes
start_dateYes
calendar_idsNo
office_indicatorsNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A3.8/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

No annotations are provided, so the description carries the full behavioral burden. It discloses key outputs (office days, earliest time, early morning warnings) and that it analyzes calendar events, but omits permission needs, rate limits, and any caveats about detection reliability.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is well-structured with a front-loaded summary, a bulleted list of provided information, and clear Args/Returns sections. It is slightly verbose in the bullet list but remains efficient and every part earns its place.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity (calendar analysis, 4 parameters) and the presence of an output schema, the description is quite complete. It explains what the tool does, what inputs mean, and what the returns contain, though it could mention any prerequisite calendar access permissions.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate. It does so by documenting all four parameters with expected formats, defaults, and meaning (e.g., 'YYYY-MM-DD' for dates, 'Defaults to config' for office_indicators). Only minor details like timezone handling are missing.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

States a specific verb (identify) and resource (days requiring office commute), and describes its analysis approach (analyzes calendar events to detect office days). It doesn't explicitly differentiate from siblings, which operate on different domains, but the purpose is crystal clear.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage context is implied by the description of the analysis and its output, but there is no explicit when-to-use, when-not-to-use, or alternative tool guidance (e.g., versus analyze_week). The agent can infer it's for commute planning, but no routing is provided.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

find_danger_zonesA

Identify scheduling problems and conflicts.

Detects:
- Days with no lunch break (meetings 12-2pm)
- Back-to-back meeting stretches longer than 3 hours
- Days with zero free time during work hours
- Overlapping events (conflicts)

Args:
    start_date: Start date (YYYY-MM-DD)
    end_date: End date (YYYY-MM-DD)
    calendar_ids: List of calendar IDs. Defaults to ["primary"].

Returns:
    List of identified scheduling problems with severity levels.
ParametersJSON Schema
NameRequiredDescriptionDefault
end_dateYes
start_dateYes
calendar_idsNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A3.6/5.0
Behavior3/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full burden, and it does add real behavioral detail: concrete thresholds (lunch window 12-2pm, back-to-back stretches over 3 hours) and that results carry severity levels. However, it never states whether the operation is read-only, whether any permissions are required, or how calendar_ids resolution behaves, leaving notable gaps for a zero-annotation tool.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The content is front-loaded and organized into Detects/Args/Returns sections, with the purpose stated first in one line. It is slightly verbose because the Args and Returns blocks partially restate the schema, but nothing is wasteful enough to hurt readability.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

An output schema exists, so the return values need not be fully explained, and the description appropriately covers detection rules, parameter formats, and the severity-bearing output. Combined with the detailed threshold list, an agent has enough to invoke it correctly, though read-only/permission semantics remain unstated.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema coverage is 0%, so the description must carry parameter meaning, and it does: date format (YYYY-MM-DD) for start_date and end_date, and that calendar_ids is a list defaulting to ["primary"]. That adds format and default semantics beyond the bare schema titles, only missing details like timezone handling.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description gives a specific verb (identify/detect) and a concrete resource (scheduling problems and conflicts), then enumerates the exact conditions it flags (no-lunch days, >3h stretches, zero free time, overlapping events). This is far more specific than the tool name alone, though it never contrasts itself with the likely overlap with analyze_week, so sibling differentiation is absent.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied by the enumerated detection types, but there is no explicit when-to-use, when-not-to-use, or mention of the alternative analyze_week sibling. An agent can infer the scenario but must guess how it relates to the other analysis tools.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

suggest_workout_slotsA

Find optimal times for booking fitness classes.

Suggests time slots based on:
- Availability (free time in calendar)
- Preferred time of day
- Duration requirements
- Commute patterns (avoids early morning before office days)

Args:
    start_date: Start date (YYYY-MM-DD)
    end_date: End date (YYYY-MM-DD)
    preferred_times: Preferred time categories. Defaults to config setting.
    min_duration_minutes: Minimum duration needed. Defaults to config setting.
    calendar_ids: List of calendar IDs. Defaults to ["primary"].

Returns:
    List of suggested workout slots ranked by quality score.
ParametersJSON Schema
NameRequiredDescriptionDefault
end_dateYes
start_dateYes
calendar_idsNo
preferred_timesNo
min_duration_minutesNo

Output Schema

ParametersJSON Schema
NameRequiredDescription
resultYes

TDQS

A3.8/5.0
Behavior4/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations, the description carries the full behavioral burden and does disclose real traits: the ranking heuristic (availability, preferred time of day, duration, commute patterns avoiding early mornings before office days) and that omitted parameters fall back to config settings. It does not state read-only/non-mutating behavior explicitly or mention auth or rate limits, so it stops short of full disclosure.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness4/5

Is the description appropriately sized, front-loaded, and free of redundancy?

Front-loads the purpose, then uses tight Args/Returns sections with no filler. Slightly list-heavy, and the Returns line restates what the output schema already conveys, but overall efficient and scannable.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness4/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a 5-parameter read-style recommendation tool with an output schema present, the description covers inputs, defaults, and the ranking behavior well enough to call it correctly. The only omissions are mutation/side-effect clarity and the enum values for preferred_times.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 0%, so the description must compensate, and its Args block documents all five parameters including date format (YYYY-MM-DD), the meaning of preferred_times, and the config-backed defaults for the three optional parameters. It doesn't enumerate the morning/lunch/evening enum values, but that gap is minor against the otherwise complete coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description opens with a specific verb+resource: 'Find optimal times for booking fitness classes,' and the name suggest_workout_slots matches. An agent can tell this is a slot-recommendation tool apart from analyze_week or find_danger_zones, though it never explicitly names or contrasts those siblings.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

Usage is implied by the framing ('for booking fitness classes') and the enumerated ranking factors, but there is no explicit statement of when to call this instead of analyze_week or check_commute_requirements, and no prerequisites or exclusions. Minimum-viable guidance only.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections.

  1. 4 tool updatesv0.1.0
    • First observedanalyze_week
    • First observedcheck_commute_requirements
    • First observedfind_danger_zones
    • First observedsuggest_workout_slots

TDQS

A4/5.0

Scored across 4 tools

Disambiguation5/5

Each tool has a clearly distinct purpose: weekly overview, problem detection, workout scheduling, and commute detection. Overlap is minimal (check_commute_requirements focuses on office days, while analyze_week includes office days as part of a broader analysis, but descriptions clearly differentiate).

Naming Consistency5/5

All tool names follow a consistent verb_noun pattern: analyze_week, find_danger_zones, suggest_workout_slots, check_commute_requirements. No deviations in style or casing.

Tool Count5/5

Four tools are well-scoped for a weekly planning assistant, covering analysis, conflict detection, scheduling suggestions, and commute needs. Each tool earns its place without redundancy.

Completeness4/5

The surface covers key planning tasks: analysis, conflict detection, workout suggestions, and commute checks. However, it lacks tools for modifying the calendar (e.g., creating events) or deeper integration like travel time estimation, which could be minor gaps for a planning assistant.

Maintenance

ActivityInactive
ResponsivenessNo issues

Related MCP Connectors

Related MCP Servers

  • F
    license
    Not graded
    quality
    D
    maintenance
    Enables natural language queries to Google Calendar API for checking appointments, availability, and events. Supports flexible time ranges, timezone handling, and both service account and OAuth authentication methods.
    -
  • F
    license
    Not graded
    quality
    D
    maintenance
    Provides AI assistants with intelligent access to Google Calendar data, enabling natural language queries about availability, upcoming events, schedule conflicts, and meeting summaries through context-aware calendar integration.
    -
  • F
    license
    Not graded
    quality
    D
    maintenance
    Enables AI assistants to manage calendars and tasks through natural language, supporting Google Calendar operations like event creation, availability checking, and smart scheduling. It features schedule analysis, task reminders, and meeting time recommendations to streamline productivity.
    -