Provides comprehensive calendar management capabilities including creating, editing, deleting, and searching events, managing multiple calendars, checking availability with freebusy queries, and accessing calendar colors and settings.
Click on "Install 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., "@Google Calendar MCP Server create a meeting with Alex tomorrow at 3pm about the Q4 strategy"
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.
I got tired of the Google Cloud setup BS, so I built this.
Connect your calendar in 30 seconds, not 3 hours.
Skip the OAuth nightmare. No Google Cloud Console. No service accounts. No headaches. Just works with Claude Desktop, Cursor, Zed, or whatever MCP client you're using.
🚀 Actually Easy Setup - 30 seconds vs 3 hours of Google Cloud hell
🔒 OAuth That Works - No token management headaches
🔧 Works Everywhere - Claude, Cursor, Zed... if it does MCP, we got you
⚡ Deploy & Forget - One-click Vercel deployment
🗓️ Full Calendar Power - Create, edit, delete events like a boss
🌐 Your Server - Host it yourself, own your data
📱 Test Drive - Web UI to make sure everything works before going live
Related MCP server: Google Calendar MCP Server
Connect your calendar:
Go to https://cal-mcp.com
Hit "Connect Google Calendar"
Do the OAuth dance
Copy your config
Add to your MCP client:
Option A: Streamable HTTP (Recommended)
{
"mcpServers": {
"google-calendar": {
"url": "https://cal-mcp.com/api/mcp"
}
}
}Option B: STDIO (Local Server)
{
"mcpServers": {
"google-calendar": {
"command": "npx",
"args": ["-y", "mcp-remote", "https://cal-mcp.com/api/mcp"]
}
}
}Grab the code:
git clone https://github.com/progrmoiz/cal-mcp
cd cal-mcp
npm installGoogle OAuth setup (yeah, still need this part):
Hit up Google Cloud Console
Make a project (or use an existing one)
Enable Google Calendar API
Create OAuth 2.0 credentials
Add this redirect URI: http://localhost:3000/api/auth/callback/google
Environment variables:
cp .env.example .env.localDrop in your Google stuff:
GOOGLE_CLIENT_ID=your_client_id
GOOGLE_CLIENT_SECRET=your_client_secret
BETTER_AUTH_SECRET=any_random_string
BETTER_AUTH_URL=http://localhost:3000Fire it up:
npm run devConnect your calendar:
Go to http://localhost:3000
Hit "Connect Google Calendar"
Do the OAuth dance
Copy your config
Built-in web interface because who wants to debug blind?
Play with Events - Create, edit, delete events right in the browser
OAuth Testing - Make sure the auth flow actually works
Debug Mode - See raw API responses when things go sideways
Sanity Check - Verify everything works before plugging into your AI
Hit http://localhost:3000 once you're running and give it a spin.
All the calendar stuff you'd expect:
list-calendars - See all your calendars
list-events - Get events for a date range
create-event - Make new events
update-event - Change existing events
delete-event - Remove events
search-events - Find events by text
get-event - Get event details
move-event - Move events between calendars
list-colors - Get color options for calendars/events
get-freebusy - Check when you're available
get-current-time - Current time and timezone info
What's under the hood:
Better Auth handling the OAuth mess
MCP server that actually works
Next.js for the web stuff
TypeScript because we're not animals
Ready to deploy? Here's what you need:
Environment Variables - Set them on your hosting platform
Database - Point to your Neon PostgreSQL URL
Google OAuth - Update redirect URIs for your domain
HTTPS - Because OAuth demands it
Better Auth handles tokens so you don't have to
Secrets stay in environment variables where they belong
Everything needs auth (obviously)
Token refresh happens automatically
Stuff not working? Try these:
Not all AI tools support MCP yet. Check if yours does before pulling your hair out.
Some tools do MCP but hate remote servers. Use the STDIO config instead.
Did you actually complete the Google login? Try connecting again from the homepage.
Bug your AI tool's developers to add MCP support. The more people ask, the faster it happens.
Built with modern technologies for reliability and ease of use:
Next.js 15 - Full-stack framework with API routes
Better Auth - Secure OAuth 2.0 authentication
MCP Handler - Model Context Protocol server implementation
Google Calendar API - Direct integration with Google's calendar services
Vercel - Serverless deployment platform
TypeScript - Type-safe development
Contributions welcome! Here's how:
🐛 Found a Bug? - Open an issue, tell us what broke
💡 Got Ideas? - Issues are perfect for brainstorming
🔧 Can Code? - PRs for fixes and features always welcome
📖 Hate Bad Docs? - Make them better!
🧪 Just Testing? - Feedback is gold
How to Contribute:
Fork it
Branch it: git checkout -b feature/cool-thing
Code it (and test it!)
PR it with a good description
If you want to contribute, here are some ideas worth tackling:
📊 Google Sheets MCP - Spreadsheets meet AI (imagine the possibilities!)
📧 Gmail MCP - Email automation that doesn't suck
☁️ Google Drive MCP - File management for the AI era
📝 Google Docs MCP - Collaborative writing with AI superpowers
Other Calendar Providers:
📅 Outlook/Microsoft 365 - Because not everyone lives in Google land
🍎 Apple Calendar (CalDAV) - For the Mac enthusiasts
Got another idea? Just build it!
The beauty of this setup is that it's dead simple to extend. Copy the auth flow, swap the API endpoints, and boom - you've got yourself a new MCP server.
Feel free to fork this repo and create a pull request. Let's build the future of productivity tools together, one API at a time. 🛠️
MIT License - do whatever you want with it.
📖 Docs: This README + code comments
🐛 Bugs: GitHub Issues
💬 Questions: GitHub Discussions
📧 Collaboration: Hit me up
Batch convert the provided list of timestamps to date format, used for processing multiple timestamps
| Name | Required | Description | Default |
|---|---|---|---|
| tsList | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the tool converts timestamps to date format but lacks details on behavioral traits such as error handling (e.g., invalid timestamps), output format specifics (e.g., date string format), performance considerations (e.g., rate limits for batch processing), or side effects. This leaves significant gaps for a tool with no annotation coverage.
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 concise and front-loaded in a single sentence: 'Batch convert the provided list of timestamps to date format, used for processing multiple timestamps.' It efficiently conveys the core purpose without unnecessary details, though it could be slightly more structured (e.g., by separating usage context).
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 (batch processing tool with no annotations, 0% schema coverage, and no output schema), the description is incomplete. It lacks critical details such as the expected timestamp format, output format, error handling, and how it differs from sibling tools. This makes it inadequate for an agent to reliably use the tool without additional context.
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?
The description adds minimal semantics beyond the input schema: it indicates 'tsList' is a 'list of timestamps' for conversion. However, with 0% schema description coverage, the schema only defines 'tsList' as an array of numbers without explaining what constitutes a valid timestamp (e.g., Unix epoch in seconds/milliseconds). The description partially compensates but doesn't fully clarify parameter meaning or constraints.
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 clearly states the tool's purpose: 'Batch convert the provided list of timestamps to date format, used for processing multiple timestamps.' It specifies the verb ('convert'), resource ('timestamps'), and scope ('batch' for multiple timestamps). However, it doesn't explicitly distinguish this from its sibling 'getDateByTimestamp' (which likely handles single timestamps), missing full sibling differentiation.
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?
The description implies usage for processing multiple timestamps ('batch convert...multiple timestamps'), suggesting this tool is for bulk operations versus single conversions. However, it doesn't explicitly state when to use this tool over alternatives like 'getDateByTimestamp' or provide exclusions (e.g., for single timestamps). The guidance is implied but not explicit.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Use the expr-eval library to evaluate the input mathematical expression and return the result.
Constant Description E The value of Math.E from your JavaScript runtime PI The value of Math.PI from your JavaScript runtime true Logical true value false Logical false value
| Name | Required | Description | Default |
|---|---|---|---|
| exp | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden. It mentions the expr-eval library and lists constants (E, PI, true, false), but doesn't disclose critical behavioral traits: error handling for invalid expressions, performance characteristics, security implications of evaluating arbitrary expressions, or what the return format looks like. For a tool with no annotation coverage, this leaves significant gaps in understanding its behavior.
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 reasonably concise but could be better structured. The first sentence clearly states the purpose, but the constant table feels appended rather than integrated. It's front-loaded with the core functionality, but the table format might not be optimal for agent comprehension. Every sentence earns its place, but the structure could be more cohesive.
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 no annotations, no output schema, and 0% schema description coverage, the description is incomplete. It covers the basic purpose and some constants but misses: return value format, error conditions, expression syntax details, and comparison to sibling tools. For a mathematical evaluation tool with these gaps, the description should provide more comprehensive context.
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?
The input schema has 1 parameter (exp) with 0% description coverage. The description adds some meaning by specifying it's a 'mathematical expression' and listing supported constants, but doesn't detail syntax rules, operator support, or expression complexity limits. With low schema coverage, the description partially compensates but doesn't fully document parameter semantics.
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 clearly states the tool's purpose: 'evaluate the input mathematical expression and return the result' using the expr-eval library. It specifies the verb (evaluate), resource (mathematical expression), and implementation detail (expr-eval library). However, it doesn't explicitly differentiate from sibling tools like batchGetDateByTimestamp, which appear to handle date/timestamp operations rather than mathematical evaluation.
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?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like batchGetDateByTimestamp, getDateByTimestamp, or getNow, nor does it specify scenarios where mathematical evaluation is appropriate versus date/timestamp operations. The constant table implies support for logical operations, but no explicit usage context is given.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Convert the provided timestamp to date format
| Name | Required | Description | Default |
|---|---|---|---|
| ts | Yes |
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries the full burden of behavioral disclosure. It states the conversion action but doesn't describe behavioral traits such as input validation (e.g., handling invalid timestamps), output format details (e.g., date string format), error handling, or performance aspects. This leaves significant gaps for a tool with no structured safety hints.
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 a single, efficient sentence that directly states the tool's function without unnecessary words. It is front-loaded and appropriately sized for a simple conversion tool, with zero wasted text.
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 tool's simplicity (1 parameter, no annotations, no output schema), the description is incomplete. It lacks details on output (e.g., date format), error cases, and usage context relative to siblings. While concise, it doesn't provide enough information for reliable agent invocation without additional assumptions.
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?
The input schema has 1 parameter with 0% description coverage, so the description must compensate. It mentions 'timestamp' but doesn't add meaning beyond the schema's 'ts' property—e.g., it doesn't specify units (seconds, milliseconds), range, or format expectations. This fails to adequately address the low schema 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 clearly states the tool's purpose: converting a timestamp to a date format. It specifies the verb 'convert' and the resource 'timestamp', making it easy to understand what the tool does. However, it doesn't explicitly differentiate from siblings like 'batchGetDateByTimestamp' (which likely processes multiple timestamps) or 'cal' (which might be a calendar tool), so it falls short of a perfect score.
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?
The description provides no guidance on when to use this tool versus alternatives. It doesn't mention sibling tools like 'batchGetDateByTimestamp' for bulk operations or 'getNow' for current time, nor does it specify prerequisites or exclusions. Usage is implied from the purpose, but explicit context is missing.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
Get the current timestamp
| Name | Required | Description | Default |
|---|---|---|---|
No parameters | |||
Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?
No annotations are provided, so the description carries full burden for behavioral disclosure. It states what the tool does but doesn't describe any behavioral traits such as rate limits, authentication needs, output format, or whether it's idempotent. For a tool with zero annotation coverage, this is a significant gap, though the simple nature of the tool mitigates some risk.
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 a single, efficient sentence ('Get the current timestamp') that is front-loaded with the core purpose. There is zero waste or redundancy, and it's appropriately sized for a simple tool. Every word earns its place, making it highly concise and well-structured.
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 tool's low complexity (0 parameters, no output schema, no annotations), the description is complete enough for basic understanding. However, it lacks details on output format (e.g., timestamp in seconds, milliseconds, or ISO string) and any behavioral context, which could be important for integration. For a simple tool, this is adequate but with clear gaps in completeness.
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?
The tool has 0 parameters, and schema description coverage is 100%, so there are no parameters to document. The description doesn't need to add parameter semantics beyond what the schema provides. Baseline for 0 parameters is 4, as the description appropriately focuses on the tool's purpose without unnecessary parameter details.
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 clearly states the action ('Get') and resource ('current timestamp'), making the purpose immediately understandable. It doesn't explicitly distinguish from siblings like 'getDateByTimestamp' or 'batchGetDateByTimestamp', but the focus on 'current' rather than conversion from a timestamp provides implicit differentiation. The description avoids tautology by not simply restating the tool name.
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?
The description implies usage context through 'current timestamp,' suggesting this tool is for obtaining the present time rather than converting timestamps (which siblings handle). However, it lacks explicit guidance on when to use this versus alternatives like 'getDateByTimestamp' or 'cal,' and doesn't mention any prerequisites or exclusions. The usage is clear but not fully articulated with alternatives.
Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.
The tools have overlapping purposes that cause confusion. 'batchGetDateByTimestamp' and 'getDateByTimestamp' both convert timestamps to dates, differing only in batch vs. single processing, which could lead to misselection. 'cal' is completely unrelated to calendar operations, evaluating mathematical expressions instead, creating a domain mismatch. Only 'getNow' stands clearly apart as a distinct timestamp retrieval tool.
The naming is inconsistent with mixed conventions and unclear patterns. 'batchGetDateByTimestamp' and 'getDateByTimestamp' use camelCase with a 'get' prefix, but 'getNow' uses snake_case-like simplicity. 'cal' is a vague abbreviation that doesn't follow any discernible pattern. There's no uniform verb_noun structure or consistent casing across the tool set.
The tool count of 4 is too few for a Google Calendar server, indicating a severe mismatch. A calendar domain typically requires CRUD operations for events, calendars, and scheduling, but this set lacks core functionalities like creating, listing, updating, or deleting events. The tools provided are more about timestamp utilities than calendar management, making the count inappropriate for the stated purpose.
The tool surface is severely incomplete for a Google Calendar server. There are no tools for managing calendar events (e.g., create_event, list_events, update_event, delete_event), calendars, or scheduling features. The existing tools focus on timestamp conversion and math evaluation, which are tangential to calendar operations, leaving significant gaps that will cause agent failures in handling typical calendar tasks.
Unclaimed servers have limited discoverability.
If you are the server author, to access and configure the admin panel.
GDPR-compliant calendar access for AI assistants. Google, Microsoft 365, Apple & more. EU-hosted.
Calendar API for AI agents: events, availability, Google/Microsoft setup, scheduling, and iCal.
Hosted Google Calendar MCP server for AI agents. No self-hosting or Google Cloud setup.
Scheduling infrastructure for AI agents across Google and Microsoft calendars.
We provide all the information about MCP servers via our MCP API.
curl -X GET 'https://glama.ai/api/mcp/v1/servers/progrmoiz/cal-mcp'
If you have feedback or need assistance with the MCP directory API, please join our Discord server
