Skip to main content
Glama

mcp-meetsync

MCP server for MeetSync — a calendar negotiation API built for AI agents.

Exposes all 19 MeetSync endpoints as MCP tools so any MCP-compatible LLM can autonomously find availability, propose meeting times, and confirm bookings — no human back-and-forth required.


Installation

npm install -g mcp-meetsync

Or run directly with npx:

npx mcp-meetsync

Related MCP server: M365 Calendar MCP Server

Configuration

The server reads two environment variables:

Variable

Required

Default

Description

MEETSYNC_API_URL

No

http://localhost:3000

Base URL of your MeetSync API

MEETSYNC_API_KEY

Yes

—

API key sent in X-API-Key header

Copy .env.example to .env and fill in your values, or pass them directly in the Claude tool definition.


Adding to Claude

Paste this snippet into your Claude desktop configuration (~/Library/Application Support/Claude/claude_desktop_config.json on macOS):

{
  "mcpServers": {
    "meetsync": {
      "command": "npx",
      "args": ["-y", "mcp-meetsync"],
      "env": {
        "MEETSYNC_API_URL": "https://api.yourmeetsync.com",
        "MEETSYNC_API_KEY": "your-api-key-here"
      }
    }
  }
}

After saving, restart Claude. The 19 MeetSync tools will appear in Claude's tool list.


Tools

All 19 MeetSync operationIds are exposed as tools. Tool names match operationIds exactly.

Participants (7 tools)

Tool

When to use

listParticipants

Browse or search registered participants

createParticipant

Register a new person before they can be scheduled

getParticipant

Look up a specific participant's timezone/provider details

updateParticipant

Change a participant's name, email, timezone, or calendar setup

deleteParticipant

Permanently remove a participant (use force to cascade)

getParticipantPreferences

Read a participant's working hours and scheduling constraints

setParticipantPreferences

Define or replace working hours, blackout windows, and buffers

Availability (2 tools)

Tool

When to use

getParticipantAvailability

Find free windows for a single participant

findMutualAvailability

Find scored slots that work for all participants simultaneously

Proposals (5 tools)

Tool

When to use

listProposals

Browse pending or historical proposals

createProposal

Propose candidate time slots and send to participants for consensus

getProposal

Check proposal status and see who has responded

cancelProposal

Withdraw a pending proposal

respondToProposal

Record a participant's acceptance or rejection

Bookings (5 tools)

Tool

When to use

listBookings

Browse confirmed, cancelled, or rescheduled meetings

createBooking

Confirm a booking from an accepted proposal, or book directly

getBooking

Retrieve full details of a specific meeting

rescheduleBooking

Move a confirmed meeting to a new time

cancelBooking

Cancel a meeting permanently


Example agent workflow

Here is a complete scheduling workflow an AI agent would follow using these tools:

1. createParticipant  ← register alice@example.com
2. createParticipant  ← register bob@example.com
3. setParticipantPreferences  ← Alice: Mon–Fri 09–17, 15 min buffer
4. setParticipantPreferences  ← Bob: Mon–Fri 10–18, no back-to-back
5. findMutualAvailability  ← find 60-min slots next week for [alice, bob]
   → returns top 5 scored slots
6. createProposal  ← "Budget Review" with top 3 slots, expires in 24h
   → proposal id: prop_abc123
7. respondToProposal  ← alice accepts, prefers slot 1
8. respondToProposal  ← bob accepts, prefers slot 1
   → proposal auto-transitions to "accepted", acceptedSlotId set
9. getProposal  ← confirm acceptedSlotId
10. createBooking  ← proposalId + slotId
    → booking confirmed, calendarEventIds written

Development

# Install dependencies
npm install

# Type-check without building
npm run typecheck

# Build to dist/
npm run build

# Run in dev mode (auto-reloads)
MEETSYNC_API_URL=http://localhost:3000 MEETSYNC_API_KEY=dev-key npm run dev

Architecture

src/
  index.ts          ← MCP Server, ListTools + CallTool handlers, stdio transport
  client.ts         ← Typed fetch wrapper: GET/POST/PUT/PATCH/DELETE + X-API-Key injection
  tools/
    participants.ts  ← 7 participant tools + handlers
    availability.ts  ← 2 availability tools + handlers
    proposals.ts     ← 5 proposal tools + handlers
    bookings.ts      ← 5 booking tools + handlers

Each tool file exports:

  • A Tool[] array with name, description, and inputSchema (strict JSON Schema)

  • A handle*Tool(name, args) async function that calls the MeetSync API via client


License

MIT

Available Tools

19 tools
cancelBookingA

Use this tool when a confirmed meeting needs to be permanently cancelled for all participants. If the intent is to move the meeting to a different time rather than cancel it entirely, use rescheduleBooking instead — cancellation is irreversible. Only bookings with status "confirmed" can be cancelled; already-cancelled bookings will return an error.

Inputs: bookingId (required).

cancelProposalA

Use this tool when the organizer needs to withdraw an entire proposal — cancelling it for all participants so no booking can result. Only proposals with status "pending" can be cancelled. Important: this is not the tool to use when a single participant wants to decline. If one participant wants to say no while others continue, call respondToProposal with status="rejected" for that participant instead.

Inputs: proposalId (required).

createBookingA

Use this tool to confirm a meeting. Choose the mode based on how you arrived here: MODE 1 — Proposal-based (used after a proposal workflow): call this when a proposal's status is "accepted". First call getProposal to retrieve the acceptedSlotId, then pass proposalId + slotId (= acceptedSlotId) here. All participant UUIDs are already known from the proposal. MODE 2 — Direct (skipping the proposal workflow): call this when you already know the exact meeting time and want to book immediately. You must provide organizerParticipantId, participantIds (all UUIDs from createParticipant), startTime, and endTime. Use this only when consensus is already established outside of MeetSync. In both modes, conflict detection runs automatically and the call fails if any participant has an overlapping confirmed booking.

Inputs: title (required), description, proposalId, slotId, +7 more.

createParticipantA

Use this tool when you need to register a new person in MeetSync so their calendar can be considered during scheduling. Must be called before a participant can appear in proposals, bookings, or availability queries. Supports Google, Outlook, and iCal providers.

Inputs: name (required), email (required), timezone, calendarProvider, +1 more.

createProposalA

Use this tool when you want to send candidate meeting times to a group and collect their votes before confirming a booking. Prerequisites: every participant in participantIds must already be registered via createParticipant; the organizerParticipantId must be one of the participantIds. Typical sequence: createParticipant for each person → findMutualAvailability to get slots → createProposal with those slots. After creation the proposal is "pending". Each participant must respond via respondToProposal (one call per person). Once all participants accept, the proposal becomes "accepted" and you call createBooking to confirm.

Inputs: title (required), organizerParticipantId (required), participantIds (required), candidateSlots (required), +4 more.

deleteParticipantA

Use this tool only when you need to permanently and irreversibly erase a participant and all their data. If the goal is simply to stop scheduling someone, use updateParticipant with status="inactive" instead — that preserves their history and can be reversed. deleteParticipant cannot be undone. By default it fails if the participant has active proposals or confirmed bookings; pass force=true only when you explicitly intend to cancel those as well.

Inputs: participantId (required), force.

findMutualAvailabilityA

Use this tool when you need to find meeting times that work for all participants simultaneously. This is the primary scheduling intelligence tool — call it to get scored candidate slots before creating a proposal. Prerequisites: every participant in participantIds must already be registered via createParticipant (UUIDs required — names and emails are not accepted). Have ready: the UUIDs of all participants, the meeting duration in minutes, and the date range to search. The returned slots are scored 0–1 by suitability (working hours, buffer fit, daily meeting load) and the start/end values can be passed directly into createProposal as candidateSlots.

Inputs: participantIds (required), durationMinutes (required), startDate (required), endDate (required), +2 more.

getBookingA

Use this tool when you need to retrieve full details about a specific booking — including its status, participants, start/end times, calendar event IDs, and any linked proposal. Useful for confirming a booking was created successfully or for building a summary to share with participants.

Inputs: bookingId (required).

getParticipantA

Use this tool when you already have the participant's UUID and need to look up their details — timezone, calendar provider, or status. Prerequisite: you must have the UUID from a prior createParticipant or listParticipants call. If you only have a name or email address and need the UUID, call listParticipants first. Note: this does not return scheduling preferences — call getParticipantPreferences for that.

Inputs: participantId (required).

getParticipantAvailabilityA

Use this tool when you need to inspect the free time windows for exactly one participant — for example, to verify they are free at a specific time before booking directly, or to understand one person's constraints before a conversation. Do not use this for group scheduling — if you need a time that works for multiple people at once, call findMutualAvailability instead. Prerequisite: you must have the participant's UUID from createParticipant or listParticipants.

Inputs: participantId (required), startDate (required), endDate (required), timezone, +1 more.

getParticipantPreferencesA

Use this tool when you need to read a participant's scheduling preferences — working hours by day, blackout windows, buffer time between meetings, and maximum meetings per day. Important: getParticipant does not return preferences; you must call this tool separately. Call this before setParticipantPreferences if you only want to update some fields, since setParticipantPreferences replaces the entire preference object.

Inputs: participantId (required).

getProposalA

Use this tool when you need to inspect a specific proposal — to see its current status, check which participants have and have not yet responded, or retrieve the acceptedSlotId you will need to pass into createBooking once the proposal is accepted. If you do not have the proposalId, call listProposals first.

Inputs: proposalId (required).

listBookingsB

Use this tool when you need to retrieve confirmed, cancelled, or rescheduled meetings. Supports filtering by participant, status, and time range. Call this to check a participant's upcoming meetings or to find a specific booking before rescheduling or cancelling it.

Inputs: participantId, status, startAfter, startBefore, +2 more.

listParticipantsA

Use this tool when you need to find participants and you do not yet have their UUID — for example, when you only know their name or email address. Also use it to verify a person is registered before scheduling, or to enumerate all active participants. If you already have a participant's UUID, use getParticipant instead.

Inputs: status, page, limit.

listProposalsA

Use this tool when you need to browse existing meeting proposals — for example, to check whether a proposal is still pending, to find proposals involving a particular participant, or to audit all pending proposals before creating a new one. Supports filtering by status and organizer.

Inputs: organizerParticipantId, participantId, status, page, +1 more.

rescheduleBookingA

Use this tool when you need to move a confirmed meeting to a new time. The new startTime must be in the future. Conflict detection runs automatically for all participants. Only bookings with status "confirmed" can be rescheduled.

Inputs: bookingId (required), startTime (required), endTime (required), reason.

respondToProposalA

Use this tool to record one participant's response (accept or reject) to a meeting proposal. This must be called once per participant — if a proposal has 3 participants, you must call this tool 3 separate times, once for each participantId. Call getProposal first to see which participants have not yet responded (check the responses array). When accepting, the participant can indicate a preferredSlotId from the proposal's candidateSlots. Once every participant has responded and all accepted, the proposal automatically becomes "accepted" and you can then call createBooking (proposal-based mode) to confirm the meeting.

Inputs: proposalId (required), participantId (required), status (required), preferredSlotId, +1 more.

setParticipantPreferencesA

Use this tool when you need to set a participant's scheduling preferences: working hours, blackout windows, buffer time, and daily meeting cap. WARNING — this is a full replacement, not a partial update: any preference not included in your call reverts to its default value, which will silently overwrite existing settings. If you only want to change one field (e.g. bufferMinutes), call getParticipantPreferences first to read the current values, then send the full merged object back here.

Inputs: participantId (required), workingHours, blackoutWindows, bufferMinutes, +1 more.

updateParticipantA

Use this tool when you need to change a participant's name, email, timezone, or calendar provider, or when you want to soft-deactivate a participant by setting status to "inactive". Only the fields you supply are changed (partial update — other fields stay as-is). Prefer this over deleteParticipant when you want to stop scheduling someone without erasing their history.

Inputs: participantId (required), name, email, timezone, +3 more.

Tool Schema Changelog

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

Loading tool schema changelog…

    TDQS

    A4.2/5.0

    Scored across 19 tools

    Disambiguation5/5

    Each tool has a clearly distinct purpose, with detailed descriptions that explicitly differentiate similar actions (e.g., cancelBooking vs. cancelProposal vs. rescheduleBooking). Descriptions warn against misuse and guide correct tool selection, eliminating ambiguity.

    Naming Consistency5/5

    All tool names consistently follow the verbNoun pattern in camelCase (e.g., createProposal, findMutualAvailability, setParticipantPreferences). Verbs are descriptive and predictable, with no mixing of conventions or vague names.

    Tool Count4/5

    19 tools cover the full scheduling domain, but the count slightly exceeds the ideal 3-15 range for a well-scoped set. Still, each tool earns its place for participant, proposal, booking, and availability management, so the slight excess is reasonable.

    Completeness5/5

    The tool surface covers the complete lifecycle: participant CRUD plus preferences, proposal creation/response/cancellation, booking CRUD with rescheduling, and availability lookup (individual and group). No obvious gaps are present for the stated purpose of meeting scheduling.

    Maintenance

    ActivityInactive
    ResponsivenessNo recent community issues

    Related MCP Connectors

    Related MCP Servers

    • A
      license
      Not graded
      quality
      D
      maintenance
      Enables AI assistants to intelligently schedule meetings by checking Microsoft Outlook calendars, finding available time slots across multiple participants, and automatically booking meetings with Teams integration. Uses Microsoft Graph API with smart fallback logic for optimal scheduling.
      1
      MIT
    • A
      license
      Not graded
      quality
      D
      maintenance
      Automates meeting logistics with tools for scheduling, availability checking, slot finding, timezone conversion, and recurring date generation. Eliminates the need for custom calendar logic by providing validated time operations and formatted invitations for applications and AI assistants.
      MIT