Weekly Planning Assistant MCP
Provides tools for analyzing Google Calendar data, including week overview, danger zone detection, workout planning, and commute planning.
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Weekly Planning Assistant MCPWhat does my week look like?"
That's it! The server will respond to your query, and you can continue using it as needed.
Here is a step-by-step guide with screenshots.
Weekly Planning Assistant MCP
An intelligent MCP server that turns your Google Calendar into actionable weekly insights through natural conversation.
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 --> AThis 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 sync2. Configure Settings
# Copy example configuration
cp config.example.json config.json
# Edit with your preferences
nano config.jsonExample 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
Go to Google Cloud Console
Click "New Project"
Name it (e.g., "Weekly Planner")
Click "Create"
B. Enable Calendar API
Search for "Google Calendar API"
Click "Enable"
C. Configure OAuth Consent Screen
Go to "APIs & Services" → "OAuth consent screen"
Select "External" user type
Fill in app name and your email
Click "Save and Continue" through all steps
Under "Test users", click "+ ADD USERS"
Add your Gmail address
D. Create OAuth Credentials
Go to "Credentials" → "Create Credentials" → "OAuth client ID"
Application type: "Desktop app" ⚠️ (NOT Web application!)
Name: "Weekly Planner Desktop"
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 authYour 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 (runecho $HOME)/absolute/path/to/weekly-planner-mcpwith 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 # DependenciesTools Provided
analyze_week- Comprehensive weekly overview with day-by-day breakdownfind_danger_zones- Identifies scheduling problems and conflictssuggest_workout_slots- Intelligent workout time suggestions with quality scoringcheck_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:00Workout 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 hoursOffice 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 workoutDevelopment
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 authTroubleshooting
"OAuth credentials not found"
Verify:
ls -la ~/.config/google-calendar-mcp/gcp-oauth.keys.jsonEnsure
GOOGLE_OAUTH_CREDENTIALSis set in Claude Desktop config
"No events returned"
Re-authenticate:
npx -y @cocal/google-calendar-mcp authVerify calendar IDs in
config.jsonCheck 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 authWhat 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 toolsanalyze_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.
| Name | Required | Description | Default |
|---|---|---|---|
| start_date | No | ||
| calendar_ids | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| days | Yes | Per-day breakdown |
| end_date | Yes | Week end date (YYYY-MM-DD) |
| start_date | Yes | Week start date (YYYY-MM-DD) |
| busiest_day | Yes | Day with most meeting hours |
| lightest_day | Yes | Day with least meeting hours |
| office_day_count | Yes | Number of office days |
| total_scheduled_hours | Yes | Total meeting hours for the week |
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| end_date | Yes | ||
| start_date | Yes | ||
| calendar_ids | No | ||
| office_indicators | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| end_date | Yes | ||
| start_date | Yes | ||
| calendar_ids | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
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.
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.
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.
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.
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.
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.
| Name | Required | Description | Default |
|---|---|---|---|
| end_date | Yes | ||
| start_date | Yes | ||
| calendar_ids | No | ||
| preferred_times | No | ||
| min_duration_minutes | No |
Output Schema
| Name | Required | Description |
|---|---|---|
| result | Yes |
TDQS
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.
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.
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.
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.
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.
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.
4 tool updates
v0.1.0- First observed
analyze_week - First observed
check_commute_requirements - First observed
find_danger_zones - First observed
suggest_workout_slots
TDQS
Scored across 4 tools
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).
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.
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.
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
Related MCP Connectors
Schedule and manage Google Calendar events directly from your workspace. Check availability, view…
Create Hevy routines and analyze your training from chat. Unofficial; BYO Hevy PRO API key.
Read tasks, habits, events and scheduling links; create and update Reclaim tasks and habits.
Calendar API for AI agents: events, availability, Google/Microsoft setup, scheduling, and iCal.
Related MCP Servers
- FlicenseNot gradedqualityDmaintenanceEnables 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.-
- FlicenseBqualityNot gradedmaintenanceGenerates AI-powered daily and weekly productivity summaries by analyzing your Slack messages, Google Calendar events, and Gmail activity with automated scheduling and smart filtering.6-
- FlicenseNot gradedqualityDmaintenanceProvides 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.-
- FlicenseNot gradedqualityDmaintenanceEnables 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.-