# How to integrate Cal MCP with LangChain

```json
{
  "title": "How to integrate Cal MCP with LangChain",
  "toolkit": "Cal",
  "toolkit_slug": "cal",
  "framework": "LangChain",
  "framework_slug": "langchain",
  "url": "https://composio.dev/toolkits/cal/framework/langchain",
  "markdown_url": "https://composio.dev/toolkits/cal/framework/langchain.md",
  "updated_at": "2026-05-06T08:04:40.039Z"
}
```

## Introduction

This guide walks you through connecting Cal to LangChain using the Composio tool router. By the end, you'll have a working Cal agent that can check if your google calendar is synced, cancel a meeting using its unique id, see if your calendar is free tomorrow afternoon through natural language commands.
This guide will help you understand how to give your LangChain agent real control over a Cal account through Composio's Cal MCP server.
Before we dive in, let's take a quick look at the key ideas and tools involved.

## Also integrate Cal with

- [OpenAI Agents SDK](https://composio.dev/toolkits/cal/framework/open-ai-agents-sdk)
- [Claude Agent SDK](https://composio.dev/toolkits/cal/framework/claude-agents-sdk)
- [Claude Code](https://composio.dev/toolkits/cal/framework/claude-code)
- [Claude Cowork](https://composio.dev/toolkits/cal/framework/claude-cowork)
- [Codex](https://composio.dev/toolkits/cal/framework/codex)
- [OpenClaw](https://composio.dev/toolkits/cal/framework/openclaw)
- [Hermes](https://composio.dev/toolkits/cal/framework/hermes-agent)
- [CLI](https://composio.dev/toolkits/cal/framework/cli)
- [Google ADK](https://composio.dev/toolkits/cal/framework/google-adk)
- [Vercel AI SDK](https://composio.dev/toolkits/cal/framework/ai-sdk)
- [Mastra AI](https://composio.dev/toolkits/cal/framework/mastra-ai)
- [LlamaIndex](https://composio.dev/toolkits/cal/framework/llama-index)
- [CrewAI](https://composio.dev/toolkits/cal/framework/crew-ai)

## TL;DR

Here's what you'll learn:
- Get and set up your OpenAI and Composio API keys
- Connect your Cal project to Composio
- Create a Tool Router MCP session for Cal
- Initialize an MCP client and retrieve Cal tools
- Build a LangChain agent that can interact with Cal
- Set up an interactive chat interface for testing

## What is LangChain?

LangChain is a framework for developing applications powered by language models. It provides tools and abstractions for building agents that can reason, use tools, and maintain conversation context.
Key features include:
- Agent Framework: Build agents that can use tools and make decisions
- MCP Integration: Connect to external services through Model Context Protocol adapters
- Memory Management: Maintain conversation history across interactions
- Multi-Provider Support: Works with OpenAI, Anthropic, and other LLM providers

## What is the Cal MCP server, and what's possible with it?

The Cal MCP server is an implementation of the Model Context Protocol that connects your AI agent and assistants like Claude, Cursor, etc directly to your Cal account. It provides structured and secure access to your scheduling and calendar management tools, so your agent can perform actions like confirming bookings, checking calendar availability, managing team members, and handling integrations on your behalf.
- Instant meeting confirmation and cancellation: Ask your agent to confirm or cancel any meeting booking using a unique identifier, streamlining the back-and-forth of scheduling.
- Real-time calendar availability checks: Let your agent fetch free/busy slots from your connected calendars to suggest optimal meeting times without revealing event details.
- Team and organization management: Effortlessly add new members to teams or update organization attribute options, making group scheduling and administration smooth.
- Integration status monitoring: Have your agent verify the synchronization status of connected calendars like Google Calendar, check Stripe payment integration, or review webhook subscriptions for reliability.
- Calendar feed verification: Use your agent to validate and check accessibility of ICS calendar feeds, ensuring external calendars are synced and up-to-date.

## Supported Tools

| Tool slug | Name | Description |
|---|---|---|
| `CAL_ADD_MEMBER_TO_TEAM_USING_ORG_AND_TEAM_ID` | Add member to team | Adds a new member to a specified team within an organization by creating a team membership. |
| `CAL_ADD_ORGANIZATION_ATTRIBUTE_OPTION` | Add organization attribute option | Adds a new option to an organization's attribute, requiring a display `value` and a `slug` unique for that attribute. |
| `CAL_CAL_DELETE_OAUTH_CLIENT_WEBHOOK` | Delete oauth client webhook | Permanently deletes a specific webhook subscription of an oauth client in the cal application, stopping its notifications. |
| `CAL_CANCEL_BOOKING_VIA_UID` | Cancel booking via uid | Cancels an existing and active cal.com booking using its unique identifier (uid). |
| `CAL_CHECK_CALENDAR_VERSION2` | Check calendar availability | Retrieves free/busy availability for a specified calendar to aid scheduling without revealing event details; requires an existing, accessible calendar, noting that data granularity can vary. |
| `CAL_CHECK_GCAL_SYNCHRONIZATION_STATUS` | Check gcal synchronization status | Call this read-only action to verify the connection and synchronization status of a user's google calendar integration with cal. |
| `CAL_CHECK_ICS_FEED_CALENDAR_ENDPOINT` | Check ics feed calendar endpoint | Checks an ics feed url (expected as a query parameter) to verify its validity, accessibility, and icalendar data integrity. |
| `CAL_CHECK_STRIPE_STATUS` | Check Stripe status | Verifies if stripe is correctly connected to the cal scheduling system and functional for processing payments, reporting only on the integration's status. |
| `CAL_CHECK_TEAM_STRIPE_INTEGRATION_STATUS` | Check team stripe integration status | Retrieves the stripe integration status and related information for a team, primarily to verify account connection, subscription details, or payment setup; this is a read-only operation that does not modify stripe settings. |
| `CAL_CONFIRM_BOOKING_BY_UID` | Confirm booking by uid | Confirms an existing booking by `bookinguid` if the booking exists and is in a state allowing confirmation (e.g., not already cancelled or confirmed); this finalizes the booking, does not modify its details, and should typically be performed once. |
| `CAL_CONNECT_TO_CALENDAR` | Connect to calendar | Initiates or checks the external connection status for a specified calendar, possibly returning a redirect url for user authorization to complete integration, without altering calendar data. |
| `CAL_CREATE_MEMBERSHIP_FOR_ORGANIZATION` | Create membership for organization | Creates a new membership or updates an existing one for a user within an organization; the user specified by userid must already exist in the system. |
| `CAL_CREATE_OAUTH_CLIENT_USER` | Create oauth client user | Creates a new managed user for an oauth client, setting profile and scheduling preferences; if `timezone` is not provided, a default schedule (mon-fri, 9am-5pm) is not created, requiring manual setup via `/schedules` endpoint before bookings are possible. |
| `CAL_CREATE_OAUTH_CLIENT_WEBHOOK_CONFIGURATION` | Create OAuth client webhook configuration | Creates a webhook for an existing oauth client to send real-time cal.com event notifications (e.g., `booking created`, `meeting ended`) to the `subscriberurl`, enabling integration with external systems or workflow automation. |
| `CAL_CREATE_ORGANIZATION_ATTRIBUTES` | Create organization attributes | Creates a new custom attribute for an existing organization, used to enhance data collection for event bookings or user profiles. |
| `CAL_CREATE_ORGANIZATION_WEBHOOK_BY_ORG_ID` | Create organization webhook by org ID | Creates a webhook for a specified, existing organization, sending notifications for selected trigger events to a designated, publicly accessible subscriber url that accepts post requests. |
| `CAL_CREATE_OR_UPDATE_TEAM_PROFILE` | Create or update team profile | Creates a new team profile, or updates one if a 'slug' matches, customizing branding, scheduling, privacy, and operational details. |
| `CAL_CREATE_PHONE_CALL_EVENT` | Create phone call event | Schedules a phone call event in cal.com using existing eventtype, organization, and team ids; this action only registers the event details and does not initiate the actual phone call. |
| `CAL_CREATE_PHONE_CALL_FOR_EVENT_TYPE` | Create phone call for event type | Creates a phone call template associated with an existing event type and team, for defining reusable call configurations like numbers and scripts; note this does not initiate an actual call. |
| `CAL_CREATE_TEAM_EVENT_TYPE` | Create team event type | Creates a new event type for a specified team in cal.com; ensure `teamid`, any provided `scheduleid`, `hosts.userid`, and `destinationcalendar` details are valid and accessible. |
| `CAL_CREATE_TEAM_EVENT_TYPES_WITH_CUSTOM_OPTIONS` | Create team event types with custom options | Creates a highly customizable cal.com team event type with extensive scheduling, booking, and host assignment options; `lengthinminutes` (as string) must be included in `lengthinminutesoptions`, destination calendar details (from `/api/v2/calendars`) must be valid, and host user ids must be valid team members. |
| `CAL_CREATE_TEAM_IN_ORGANIZATION` | Create team in organization | Creates a new team with customizable attributes within an existing and accessible cal.com organization specified by orgid. |
| `CAL_CREATE_TEAM_MEMBERSHIP_WITH_ROLE` | Create team membership with role | Adds a user to a team with a specified role, acceptance status, and impersonation settings; ensure `teamid` and `userid` refer to existing, valid entities. |
| `CAL_CREATE_USER_AVAILABILITY_SCHEDULE` | Create user availability schedule | Creates a cal.com user availability schedule, defining its name, timezone, weekly recurring availability, and specific date overrides; if `isdefault` is true, this schedule replaces any existing default and applies to event types not linked to a specific schedule. |
| `CAL_CREATE_USER_SCHEDULE_IN_ORGANIZATION` | Create user schedule in organization | Creates a new schedule defining a user's availability with weekly slots and date-specific overrides in an organization; setting 'isdefault' to true may replace an existing default schedule for the user. |
| `CAL_CREATE_WEBHOOK_FOR_EVENT_TYPE` | Create webhook for event type | Creates a webhook for an existing `eventtypeid` in cal.com, sending notifications for specified `triggers` to a `subscriberurl` that handles post requests. |
| `CAL_DECLINE_BOOKING_WITH_REASON` | Decline booking with reason | Declines a pending booking using its bookinguid, optionally with a reason; this action is irreversible and applies only to bookings awaiting confirmation. |
| `CAL_DELETE_CONFERENCE_APP_CONNECTION` | Delete conference app connection | Disconnects the specified conferencing application (e.g., 'zoom', 'google meet') for the cal.com account, immediately terminating any ongoing call or meeting; use with caution. |
| `CAL_DELETE_EVENT_TYPE_BY_ID` | Delete event type by id | Permanently deletes an existing event type by its id, which invalidates its scheduling links; the operation is irreversible, and while existing bookings are unaffected, no new bookings can be made for this event type. |
| `CAL_DELETE_EVENT_TYPE_IN_TEAM` | Delete event type in team | Permanently removes an event type's configuration from a team's scheduling options (e.g., for cleanup); this action is irreversible and requires the event type to be associated with the team. |
| `CAL_DELETE_MEMBERSHIP_IN_TEAM` | Delete membership in team | Use to permanently remove a user's membership from a specific team within an organization, which revokes their team-associated access but does not remove them from the organization. |
| `CAL_DELETE_OAUTH_CLIENT_USER` | Delete oauth client user | Irreversibly revokes a specific user's association with a given oauth client, without deleting the user's cal account. |
| `CAL_DELETE_ORGANIZATION_ATTRIBUTE` | Delete organization attribute | Permanently deletes an existing attribute (specified by `attributeid`) from an existing organization (specified by `orgid`); this action is irreversible and may affect features dependent on the attribute. |
| `CAL_DELETE_ORGANIZATION_ATTRIBUTE_OPTION` | Delete organization attribute option | Permanently deletes a specified option from an organization's attribute, typically to remove an unnecessary configuration choice. |
| `CAL_DELETE_ORGANIZATION_MEMBERSHIP` | Delete organization membership | Irreversibly deletes a user's membership from an organization, removing all associated access and permissions; the response confirms deletion without returning details of the deleted membership. |
| `CAL_DELETE_ORG_WEBHOOK` | Delete org webhook | Permanently deletes an organization's webhook, which stops all its notifications; this action is irreversible and the webhook cannot be recovered. |
| `CAL_DELETE_SCHEDULE_BY_ID` | Delete schedule by id | Permanently deletes a specific schedule using its unique identifier, which must correspond to an existing schedule. |
| `CAL_DELETE_SELECTED_CALENDARS` | Delete selected calendars | Removes a specified, currently selected calendar from the user's active list within the application, without deleting it from the external provider. |
| `CAL_DELETE_SELECTED_SLOT` | Delete selected slot | Deletes a previously selected time slot from the cal schedule using its `uid`; the slot must exist and this action is irreversible. |
| `CAL_DELETE_TEAM_BY_ID` | Delete team by id | Permanently and irreversibly deletes an existing team and all its associated data from the cal system, using the team's unique `teamid`. |
| `CAL_DELETE_TEAM_FROM_ORGANIZATION` | Delete team from organization | Permanently and irreversibly deletes a specific team (and all its associated data, members, and linked projects/events) from an organization, when the team is no longer needed or during organizational restructuring. |
| `CAL_DELETE_TEAM_MEMBERSHIPS_BY_ID` | Delete team memberships by id | Irreversibly removes a user's team membership in the cal application, revoking access to that specific team; the user's overall cal account remains active. |
| `CAL_DELETE_USER_ATTRIBUTE_OPTION` | Delete user attribute option | Removes a custom attribute option (e.g., skill, role) currently assigned to a user within an organization; this operation is irreversible. |
| `CAL_DELETE_USER_FROM_ORGANIZATION` | Delete user from organization | Permanently removes a user from a specific organization (user's system-wide account is unaffected), revoking their access rights therein; this action is irreversible via api and expects the user to be a current member. |
| `CAL_DELETE_USER_SCHEDULE` | Delete user schedule | Permanently deletes a specific user's schedule, provided the organization, user, and schedule (identified by `orgid`, `userid`, and `scheduleid`) exist. |
| `CAL_DELETE_WEBHOOK_BY_ID` | Delete webhook by id | Permanently deletes an existing webhook by its `webhookid`, stopping future notifications; this action is irreversible. |
| `CAL_DELETE_WEBHOOK_FOR_EVENT_TYPE` | Delete webhook for event type | Permanently deletes a specific webhook for an event type, halting its real-time notifications; this operation is irreversible and leaves the event type and other webhooks untouched. |
| `CAL_DELETE_WEBHOOKS_FOR_EVENT_TYPE` | Delete webhooks for event type | Call this to irreversibly delete all webhooks for a specific `eventtypeid` if the event type exists; details of deleted webhooks are not returned. |
| `CAL_DISCONNECT_CALENDAR_USING_CREDENTIAL_ID` | Disconnect calendar using credential id | Disconnects a calendar integration by its provider name and credential id, irreversibly revoking cal's access; external calendar data remains unaffected. |
| `CAL_FETCH_ALL_BOOKINGS` | Fetch all bookings | Fetches a list of bookings, optionally filtered by status, attendee, date range, or by event/team ids (which must belong to/include the authenticated user respectively), with support for pagination and sorting. |
| `CAL_FETCH_EVENT_TYPE_DETAILS` | Fetch event type details | Fetches all configuration settings and characteristics for a single event type (identified by orgid, teamid, and eventtypeid), which must exist and be accessible; this read-only action cannot list, create, or modify event types. |
| `CAL_FETCH_ORGANIZATION_ATTRIBUTE_BY_ID` | Fetch organization attribute by id | Retrieves a specific attribute of an organization, useful for fetching a single data point instead of the entire organization record. |
| `CAL_FETCH_PROVIDER_ACCESS_TOKEN` | Fetch provider access token | Fetches an oauth access token for the specified `clientid` to authenticate api calls; this action only retrieves the token, not managing scheduling or calendar events. |
| `CAL_FETCH_SCHEDULE_BY_ID` | Fetch schedule by id | Fetches comprehensive details for a specific, existing schedule using its `scheduleid`. |
| `CAL_FETCH_USER_SCHEDULE_BY_ORG_ID` | Fetch user schedule by org id | Fetches a specific user's schedule, potentially including events and availability, using `orgid`, `userid`, and `scheduleid`. |
| `CAL_FETCH_WEBHOOK_BY_EVENT_TYPE_ID` | Fetch webhook by event type id | Retrieves details for a single, specific webhook using its `webhookid` and associated `eventtypeid`. |
| `CAL_FORCE_REFRESH_USER_OAUTH_CLIENT` | Force refresh user oauth client | Forces an immediate refresh of oauth tokens for a specified user and client, bypassing the normal expiration cycle, typically when existing tokens are suspected to be invalid or fresh credentials are required; ensure the user exists, the client is registered, and prior authorization is valid. |
| `CAL_GET_ALL_TIMEZONES` | Get all timezones | Retrieves all supported time zone identifiers (e.g., 'america/new york', 'europe/london') and their associated metadata, excluding specific dst changes or precise utc offset details. |
| `CAL_GET_AVAILABLE_SLOTS_INFO` | Get available slots info | Retrieves available time slots for scheduling by considering existing bookings and availability, based on criteria like a specified time range and event type. |
| `CAL_GET_CONFERENCE_OAUTH_AUTHORIZATION_URL` | Get conference OAuth authorization url | Generates an oauth 2.0 authorization url for a supported conferencing `app` to initiate or refresh its integration with cal.com. |
| `CAL_GET_DEFAULT_SCHEDULE_DETAILS` | Get default schedule details | Retrieves the cal system's global default schedule configuration, not custom or user-specific ones. |
| `CAL_GET_EVENT_TYPE_BY_TEAM_ID` | Get event type by team id | Retrieves a specific event type by its id, requiring that the event type is associated with the given team id. |
| `CAL_GET_GOOGLE_CALENDAR_OAUTH_AUTHENTICATION_URL` | Get google calendar oauth authentication url | Generates the initial google calendar oauth 2.0 authorization url for user redirection to begin the authentication and authorization process. |
| `CAL_GET_OAUTH_CLIENTS_USER` | Get oauth clients user | Retrieves users associated with a specific oauth client (identified by a valid `clientid`) for auditing access or managing permissions. |
| `CAL_GET_ORGANIZATION_ID` | Get organization ID | Retrieves all organization ids associated with the currently authenticated user. |
| `CAL_GET_ORGANIZATION_SCHEDULES` | Get organization schedules | Retrieves a list of schedules (e.g., events, appointments) for an organization, providing basic schedule information, not detailed individual event data. |
| `CAL_GET_ORGANIZATION_TEAMS_EVENT_TYPES` | Get organization teams event types | Retrieves event types, including names, durations, and custom settings for team scheduling, for all teams within an existing organization specified by `orgid`. |
| `CAL_GET_ORGANIZATION_USER_SCHEDULES` | Get organization user schedules | Fetches all schedule information for a specific user within an organization; handle potential pagination for extensive schedules. |
| `CAL_GET_SCHEDULE_FOR_USER_IN_TEAM` | Get schedule for user in team | Fetches all scheduled events or appointments for a specified user within their team and organization. |
| `CAL_GET_STRIPE_CONNECT_INFO` | Get stripe connect info | Retrieves stripe connect account details (id, charges/payouts status, verification, settings) for the user's linked cal.com account; response may be empty or indicate no integration if no account is linked. |
| `CAL_GET_TEAM_DETAILS_BY_ORG_ID_AND_TEAM_ID` | Get team details by organization ID and team ID | Retrieves comprehensive details (e.g., members, roles, metadata) for a specific team using its `teamid` within an organization specified by `orgid`. |
| `CAL_GET_TEAM_INFORMATION_BY_TEAM_ID` | Get team information by team ID | Fetches comprehensive details for an existing team using its unique id; returned fields may vary by team configuration and user permissions. |
| `CAL_GET_TEAMS_LIST` | Get teams list | Retrieves all teams the user belongs to, including their names and members. |
| `CAL_GET_WEBHOOK_BY_ID` | Get webhook by id | Retrieves details for an existing and accessible webhook by its id; this is a read-only operation. |
| `CAL_HANDLE_CONFERENCING_OAUTH_CALLBACK_FOR_APP` | Handle conferencing oauth callback for app | Processes an oauth 2.0 callback for a conferencing `app`, exchanging the `code` and `state` for access credentials; ensure an oauth flow was previously initiated. |
| `CAL_LIST_EVENT_TYPES` | List event types | Retrieves cal event types, filterable by `username` (required if `eventslug` is provided), multiple `usernames`, or organization details (`orgslug` or `orgid`). |
| `CAL_LIST_ORGANIZATION_MEMBERSHIPS` | List organization memberships | Retrieves all memberships for a given organization, including user details, roles, status, and membership dates. |
| `CAL_LIST_TEAM_EVENT_TYPES_BY_ORG_AND_TEAM_ID` | List team event types by org and team id | Retrieves all event types for a specific team within an organization, optionally filtering by a specific event slug. |
| `CAL_MARK_BOOKING_ABSENT_FOR_UID` | Mark booking absent for UID | Marks the host and/or specified attendees as absent for an existing booking, typically used after a scheduled event to record no-shows. |
| `CAL_MODIFY_ORGANIZATION_MEMBERSHIP_BY_ID` | Modify organization membership by id | Updates an organization membership's status (accepted), role, or impersonation settings, identified by `orgid` and `membershipid` in the path; requires at least one of these fields in the request to apply changes. |
| `CAL_MODIFY_ORG_ATTRIBUTE_BY_ID` | Modify org attribute by id | Partially updates an organization attribute using `orgid` and `attributeid`, allowing modification of its name, slug, type, or enabled status; changing the 'type' may affect existing data. |
| `CAL_PATCH_ORGANIZATION_ATTRIBUTE_OPTION` | Patch organization attribute option | Partially updates a specific option for an organization's attribute, modifying its 'value' and/or 'slug'; at least one of 'value' or 'slug' must be provided. |
| `CAL_PATCH_ORGANIZATION_USER_DETAILS` | Patch organization user details | Partially updates details for a user that exists within the specified organization. |
| `CAL_PATCH_TEAM_DETAILS_BY_ID` | Patch team details by ID | Updates specified details for an existing team identified by `teamid`; unspecified fields remain unchanged. |
| `CAL_PATCH_WEBHOOK_EVENT_TYPE` | Patch webhook event type | Updates configuration (e.g., payload template, active status, url, triggers, secret) for an existing webhook tied to a specific event type. |
| `CAL_POST_CALENDAR_CREDENTIALS` | Post calendar credentials | Use to submit/update authentication credentials (passed in the request body) for an existing calendar, enabling cal to connect with external calendar services for synchronization. |
| `CAL_POST_CONFERENCING_APP_CONNECT` | Connect conferencing app | Connects or reconnects cal.com with a specified conferencing application to enable future virtual meeting scheduling, but does not itself create or schedule meetings. |
| `CAL_POST_NEW_BOOKING_REQUEST` | Post a new booking request | Creates a new booking for an active event type, scheduling it for a specified start time (preferably in the future) with primary attendee details and optional customizations. |
| `CAL_POST_ORG_ATTRIBUTE_OPTION_BY_USER` | Assign or create attribute option for user | Assigns an existing attribute option (using `attributeoptionid`) or creates a new one (using `value`) for a user, linking it to a specified `attributeid` which must already exist within the organization. |
| `CAL_POST_SELECTED_CALENDARS` | Add selected calendar | Links a new external calendar or updates an existing link to one, enabling synchronization with the cal application by specifying the `integration` provider, the calendar's `externalid`, and the `credentialid`. |
| `CAL_POST_USER_TO_ORGANIZATION` | Post user to organization | Adds a new user to an existing organization (identified by `orgid` in path), requiring user's `email` and allowing extensive optional profile customization. |
| `CAL_POST_WEBHOOK_EVENT` | Post webhook event | Creates a new cal.com webhook subscription to send real-time notifications for specified calendar events to a publicly accessible subscriber url. |
| `CAL_REASSIGN_BOOKING_TO_ANOTHER_USER` | Reassign booking to another user | Reassigns an existing, active booking to a specified, authorized user; does not notify participants of this change. |
| `CAL_REASSIGN_BOOKING_WITH_UID` | Reassign booking with uid | Reassigns the specified booking to a new team member, who is determined by the system rather than being specified in the request. |
| `CAL_REFRESH_OAUTH_TOKEN_FOR_CLIENT_ID` | Refresh oauth token for client id | Refreshes an oauth access token for a specified `clientid` and managed user using their `refreshtoken`, enabling continued api access when the current token is near or past expiry. |
| `CAL_RESCHEDULE_BOOKING_BY_UID` | Reschedule booking by uid | Reschedules an existing booking (identified by `bookinguid`) to a new time, provided the new slot's availability is confirmed beforehand; all other rescheduling parameters (e.g., new date, time) must be sent in the post request body, not via this action's direct parameters. |
| `CAL_RESERVE_SLOT_FOR_EVENT` | Reserve slot for event | Temporarily reserves an available time slot for an existing and bookable event type, useful for high-demand slots to prevent double-bookings while the user completes the booking. |
| `CAL_RETRIEVE_ATTRIBUTE_OPTIONS_FOR_ORG` | Retrieve attribute options for org | Retrieves all available options for a specific attribute within a designated organization, requiring valid and associated `orgid` and `attributeid`. |
| `CAL_RETRIEVE_BOOKING_DETAILS_BY_UID` | Retrieve booking details by uid | Fetches comprehensive details for an existing booking, identified by its `bookinguid`. |
| `CAL_RETRIEVE_CALENDAR_BUSY_TIMES` | Retrieve calendar busy times | To find busy calendar slots for scheduling/conflict detection, call this with a valid `credentialid`, an `externalid` accessible by it, and a recognized iana `loggedinuserstz`; returns only busy intervals, not event details or free slots. |
| `CAL_RETRIEVE_CALENDAR_LIST` | Retrieve calendar list | Retrieves a list of all calendar summaries (no event details) associated with the authenticated user's account. |
| `CAL_RETRIEVE_CURRENT_TEAM_FOR_ORGANIZATION` | Retrieve current team for organization | Retrieves details of the team(s) for the currently authenticated user within the specified organization `orgid`. |
| `CAL_RETRIEVE_DEFAULT_CONFERENCING_SETTINGS` | Retrieve default conferencing settings | Retrieves an account's or organization's read-only default conferencing settings in cal.com (e.g., video platform, meeting duration) to inform event creation or ensure consistency. |
| `CAL_RETRIEVE_EVENT_TYPE_BY_ID` | Retrieve event type by id | Retrieves comprehensive details for a specific, existing cal.com event type using its unique id; this is a read-only action and does not return associated events or bookings. |
| `CAL_RETRIEVE_MEMBERSHIP_FROM_ORGANIZATION` | Retrieve membership from organization | Retrieves detailed information about a specific membership within a particular organization. |
| `CAL_RETRIEVE_MY_INFORMATION` | Retrieve my information | Retrieves the authenticated user's core profile information (e.g., name, email, timezone); does not retrieve related data like calendar events or schedules. |
| `CAL_RETRIEVE_OAUTH_CLIENT_USER_BY_ID` | Retrieve OAuth client user by ID | Retrieves detailed information for an existing user specifically associated with an existing oauth client. |
| `CAL_RETRIEVE_OAUTH_CLIENT_WEBHOOK_BY_ID` | Retrieve oauth client webhook by id | Retrieves a specific webhook using its `webhookid` and the `clientid` of its associated oauth client. |
| `CAL_RETRIEVE_ORGANIZATION_ATTRIBUTES` | Retrieve organization attributes | Retrieves detailed attributes (e.g., configurations, settings, metadata) for an organization, identified by its `orgid`, which must correspond to an existing organization. |
| `CAL_RETRIEVE_ORGANIZATION_ATTRIBUTES_OPTIONS` | Retrieve organization attributes options | Fetches all available attribute options for a specific user within a given organization, provided the organization and user exist and the user is part of the organization. |
| `CAL_RETRIEVE_ORGANIZATION_WEBHOOK_BY_ID` | Retrieve organization webhook by id | Retrieves detailed information, including configuration and status, for a specific webhook by its id (`webhookid`) within a given organization (`orgid`). |
| `CAL_RETRIEVE_ORGANIZATION_WEBHOOKS_BY_ORG_ID` | Retrieve organization webhooks by org ID | Retrieves a list of webhooks for an organization specified by `orgid`, supporting pagination; this is a read-only operation. |
| `CAL_RETRIEVE_PROVIDER_DETAILS` | Retrieve provider details | Retrieves detailed information for an existing provider in the cal scheduling system using their unique client id. |
| `CAL_RETRIEVE_SCHEDULES_LIST` | Retrieve schedules list | Retrieves a comprehensive list of all schedules associated with the authenticated user's cal.com account or organization. |
| `CAL_RETRIEVE_TEAM_DETAILS_IN_ORGANIZATION` | Retrieve team details in organization | Retrieves a paginated list of teams and their details for a specific organization id; individual team member details or schedules are not included. |
| `CAL_RETRIEVE_TEAM_EVENT_TYPES` | Retrieve team event types | Retrieves event types for a team within the cal scheduling system; this action does not provide details on scheduled instances or member availability. |
| `CAL_RETRIEVE_TEAM_MEMBERSHIP_BY_ID` | Retrieve team membership by id | Retrieves detailed information, including role and status, for a specific team membership using its id, for a given organization and team. |
| `CAL_RETRIEVE_TEAM_MEMBERSHIP_DETAILS` | Retrieve team membership details | Retrieves detailed attributes for a specific team membership by its id and the team id, such as member information, role, and status; does not list all team members. |
| `CAL_RETRIEVE_TEAM_MEMBERSHIPS` | Retrieve team memberships | Retrieves a list of memberships, detailing member roles and statuses, for an existing team specified by `teamid`, with support for pagination. |
| `CAL_RETRIEVE_TEAM_MEMBERSHIPS_FOR_ORGANIZATION` | Retrieve team memberships for organization | Retrieves all user memberships, including their roles and states, for a specific team within an organization. |
| `CAL_RETRIEVE_USERS_IN_ORGANIZATION` | Retrieve users in organization | Retrieves users associated with a specific organization id, excluding individual scheduling or calendar data; the `orgid` must be a valid identifier for an existing organization. |
| `CAL_RETRIEVE_V2_CONFERENCING_INFO` | Retrieve v2 conferencing info | Retrieves an authenticated cal user's or organization's video conferencing configurations, capabilities, and installed apps, useful for understanding options before scheduling or verifying setups; provider availability may vary by subscription or settings. |
| `CAL_RETRIEVE_WEBHOOK_DETAILS_FOR_OAUTH_CLIENT` | Retrieve webhook details for oauth client | Retrieves a list of webhooks for a specific oauth client, supporting pagination. |
| `CAL_RETRIEVE_WEBHOOKS_FOR_EVENT_TYPE` | Retrieve webhooks for event type | Retrieves a paginated list of webhooks (including urls, subscribed events, and status) for a specified, existing event type id, useful for auditing configurations or troubleshooting. |
| `CAL_RETRIEVE_WEBHOOKS_LIST` | Retrieve webhooks list | Retrieves a paginated list of webhooks from the user's cal scheduling system account, which are used for real-time notifications on events like new bookings, cancellations, or updates. |
| `CAL_SAVE_CALENDAR_ENTRY` | Save calendar entry | Saves or updates a calendar's settings using a get request, typically for data already on the server or simple updates via query parameters. |
| `CAL_SAVE_CALENDAR_ICS_FEEDS` | Save calendar ics feeds | Imports and saves one or more publicly accessible external icalendar (ics) feed urls into the cal.com calendar system. |
| `CAL_SAVE_OAUTH_CREDENTIALS_VIA_GCAL_API` | Save OAuth credentials via GCal API | Completes the google calendar oauth 2.0 flow by exchanging the `code` and `state` (received from google's redirect after user consent) for access and refresh tokens. |
| `CAL_SAVE_STRIPE_DETAILS` | Save stripe details | Completes the stripe oauth flow by saving stripe details; call this when a user is redirected back from stripe with an authorization `code` and `state`. |
| `CAL_SET_DEFAULT_CONFERENCING_APP` | Set default conferencing app | Sets the specified, valid, and configured conferencing application as the default for new meetings for the authenticated user. |
| `CAL_UPDATE_DESTINATION_CALENDAR_INTEGRATION` | Update destination calendar integration | Updates the destination calendar for syncing events, using `integration` and `externalid` (typically from `/calendars` endpoint). |
| `CAL_UPDATE_OAUTH_CLIENT_USER_SETTINGS` | Update OAuth client user settings | Updates specified profile and scheduling preference fields for a user associated with an oauth client; `defaultscheduleid`, if provided, must be an existing, valid schedule for the user. |
| `CAL_UPDATE_OAUTH_CLIENT_WEBHOOK` | Update oauth client webhook | Updates specified properties of an existing webhook for an oauth client; omitted fields remain unchanged. |
| `CAL_UPDATE_SCHEDULE_BY_ID` | Update schedule by ID | Updates an existing schedule by its id, allowing partial modification of properties; providing `availability` or `overrides` replaces them entirely. |
| `CAL_UPDATE_TEAM_INFORMATION_BY_ID` | Update team information by id | Updates an existing team's information by its id within a specified organization; the `slug`, if provided, must be unique within the organization. |
| `CAL_UPDATE_TEAM_MEMBERSHIP_BY_ID` | Update team membership by id | Updates specified properties (e.g., acceptance status, role, impersonation settings) of an existing team membership, identified by `teamid` and `membershipid`, supporting partial updates where only provided fields are modified. |
| `CAL_UPDATE_TEAM_MEMBERSHIP_PROPERTIES` | Update team membership properties | Updates attributes like acceptance status, role, or impersonation settings for an existing team membership; only provided fields are changed, and this action cannot create or delete memberships. |
| `CAL_UPDATE_USER_PROFILE_DETAILS` | Update user profile details | Updates the profile information and preferences for the authenticated user, affecting only the fields provided in the request. |
| `CAL_UPDATE_USER_SCHEDULE_IN_ORGANIZATION` | Update user schedule in organization | Modifies an existing schedule for a specified user within an organization by updating only the provided fields; the organization, user, and schedule must already exist. |
| `CAL_UPDATE_WEBHOOK_BY_ID` | Update webhook by id | Updates an existing cal.com webhook by its `webhookid`, allowing partial modification of its attributes; only explicitly provided fields will be changed. |
| `CAL_UPDATE_WEBHOOK_FOR_ORGANIZATION` | Update webhook for organization | Use this action to modify settings of an already created webhook for an organization, such as its target url, active status, or the events that trigger it. |

## Supported Triggers

None listed.

## Creating MCP Server - Stand-alone vs Composio SDK

The Cal MCP server is an implementation of the Model Context Protocol that connects your AI agent to Cal. It provides structured and secure access so your agent can perform Cal operations on your behalf through a secure, permission-based interface.
With Composio's managed implementation, you don't have to create your own developer app. For production, if you're building an end product, we recommend using your own credentials. The managed server helps you prototype fast and go from 0-1 faster.

## Step-by-step Guide

### 1. Prerequisites

No description provided.

### 1. Getting API Keys for OpenAI and Composio

OpenAI API Key
- Go to the [OpenAI dashboard](https://platform.openai.com/settings/organization/api-keys) and create an API key. You'll need credits to use the models, or you can connect to another model provider.
- Keep the API key safe.
Composio API Key
- Log in to the [Composio dashboard](https://dashboard.composio.dev?utm_source=toolkits&utm_medium=framework_docs).
- Navigate to your API settings and generate a new API key.
- Store this key securely as you'll need it for authentication.

### 2. Install dependencies

No description provided.
```python
pip install composio-langchain langchain-mcp-adapters langchain python-dotenv
```

```typescript
npm install @composio/langchain @langchain/core @langchain/openai @langchain/mcp-adapters dotenv
```

### 3. Set up environment variables

Create a .env file in your project root.
What's happening:
- COMPOSIO_API_KEY authenticates your requests to Composio's API
- COMPOSIO_USER_ID identifies the user for session management
- OPENAI_API_KEY enables access to OpenAI's language models
```bash
COMPOSIO_API_KEY=your_composio_api_key_here
COMPOSIO_USER_ID=your_composio_user_id_here
OPENAI_API_KEY=your_openai_api_key_here
```

### 4. Import dependencies

No description provided.
```python
from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain.agents import create_agent
from dotenv import load_dotenv
from composio import Composio
import asyncio
import os

load_dotenv()
```

```typescript
import { Composio } from '@composio/core';
import { LangchainProvider } from '@composio/langchain';
import { MultiServerMCPClient } from "@langchain/mcp-adapters";
import { createAgent } from "langchain";
import * as readline from 'readline';
import 'dotenv/config';

dotenv.config();
```

### 5. Initialize Composio client

What's happening:
- We're loading the COMPOSIO_API_KEY from environment variables and validating it exists
- Creating a Composio instance that will manage our connection to Cal tools
- Validating that COMPOSIO_USER_ID is also set before proceeding
```python
async def main():
    composio = Composio(api_key=os.getenv("COMPOSIO_API_KEY"))

    if not os.getenv("COMPOSIO_API_KEY"):
        raise ValueError("COMPOSIO_API_KEY is not set")
    if not os.getenv("COMPOSIO_USER_ID"):
        raise ValueError("COMPOSIO_USER_ID is not set")
```

```typescript
const composioApiKey = process.env.COMPOSIO_API_KEY;
const userId = process.env.COMPOSIO_USER_ID;

if (!composioApiKey) throw new Error('COMPOSIO_API_KEY is not set');
if (!userId) throw new Error('COMPOSIO_USER_ID is not set');

async function main() {
    const composio = new Composio({
        apiKey: composioApiKey as string,
        provider: new LangchainProvider()
    });
```

### 6. Create a Tool Router session

What's happening:
- We're creating a Tool Router session that gives your agent access to Cal tools
- The create method takes the user ID and specifies which toolkits should be available
- The returned session.mcp.url is the MCP server URL that your agent will use
- This approach allows the agent to dynamically load and use Cal tools as needed
```python
# Create Tool Router session for Cal
session = composio.create(
    user_id=os.getenv("COMPOSIO_USER_ID"),
    toolkits=['cal']
)

url = session.mcp.url
```

```typescript
const session = await composio.create(
    userId as string,
    {
        toolkits: ['cal']
    }
);

const url = session.mcp.url;
```

### 7. Configure the agent with the MCP URL

No description provided.
```python
client = MultiServerMCPClient({
    "cal-agent": {
        "transport": "streamable_http",
        "url": session.mcp.url,
        "headers": {
            "x-api-key": os.getenv("COMPOSIO_API_KEY")
        }
    }
})

tools = await client.get_tools()

agent = create_agent("gpt-5", tools)
```

```typescript
const client = new MultiServerMCPClient({
    "cal-agent": {
        transport: "http",
        url: url,
        headers: {
            "x-api-key": process.env.COMPOSIO_API_KEY
        }
    }
});

const tools = await client.getTools();

const agent = createAgent({ model: "gpt-5", tools });
```

### 8. Set up interactive chat interface

No description provided.
```python
conversation_history = []

print("Chat started! Type 'exit' or 'quit' to end the conversation.\n")
print("Ask any Cal related question or task to the agent.\n")

while True:
    user_input = input("You: ").strip()

    if user_input.lower() in ['exit', 'quit', 'bye']:
        print("\nGoodbye!")
        break

    if not user_input:
        continue

    conversation_history.append({"role": "user", "content": user_input})
    print("\nAgent is thinking...\n")

    response = await agent.ainvoke({"messages": conversation_history})
    conversation_history = response['messages']
    final_response = response['messages'][-1].content
    print(f"Agent: {final_response}\n")
```

```typescript
let conversationHistory: any[] = [];

console.log("Chat started! Type 'exit' or 'quit' to end the conversation.\n");
console.log("Ask any Cal related question or task to the agent.\n");

const rl = readline.createInterface({
    input: process.stdin,
    output: process.stdout,
    prompt: 'You: '
});

rl.prompt();

rl.on('line', async (userInput: string) => {
    const trimmedInput = userInput.trim();

    if (['exit', 'quit', 'bye'].includes(trimmedInput.toLowerCase())) {
        console.log("\nGoodbye!");
        rl.close();
        process.exit(0);
    }

    if (!trimmedInput) {
        rl.prompt();
        return;
    }

    conversationHistory.push({ role: "user", content: trimmedInput });
    console.log("\nAgent is thinking...\n");

    const response = await agent.invoke({ messages: conversationHistory });
    conversationHistory = response.messages;

    const finalResponse = response.messages[response.messages.length - 1]?.content;
    console.log(`Agent: ${finalResponse}\n`);
        
        rl.prompt();
    });

    rl.on('close', () => {
        console.log('\n👋 Session ended.');
        process.exit(0);
    });
```

### 9. Run the application

No description provided.
```python
if __name__ == "__main__":
    asyncio.run(main())
```

```typescript
main().catch((err) => {
    console.error('Fatal error:', err);
    process.exit(1);
});
```

## Complete Code

```python
from langchain_mcp_adapters.client import MultiServerMCPClient
from langchain.agents import create_agent
from dotenv import load_dotenv
from composio import Composio
import asyncio
import os

load_dotenv()

async def main():
    composio = Composio(api_key=os.getenv("COMPOSIO_API_KEY"))
    
    if not os.getenv("COMPOSIO_API_KEY"):
        raise ValueError("COMPOSIO_API_KEY is not set")
    if not os.getenv("COMPOSIO_USER_ID"):
        raise ValueError("COMPOSIO_USER_ID is not set")
    
    session = composio.create(
        user_id=os.getenv("COMPOSIO_USER_ID"),
        toolkits=['cal']
    )

    url = session.mcp.url
    
    client = MultiServerMCPClient({
        "cal-agent": {
            "transport": "streamable_http",
            "url": url,
            "headers": {
                "x-api-key": os.getenv("COMPOSIO_API_KEY")
            }
        }
    })
    
    tools = await client.get_tools()
  
    agent = create_agent("gpt-5", tools)
    
    conversation_history = []
    
    print("Chat started! Type 'exit' or 'quit' to end the conversation.\n")
    print("Ask any Cal related question or task to the agent.\n")
    
    while True:
        user_input = input("You: ").strip()
        
        if user_input.lower() in ['exit', 'quit', 'bye']:
            print("\nGoodbye!")
            break
        
        if not user_input:
            continue
        
        conversation_history.append({"role": "user", "content": user_input})
        print("\nAgent is thinking...\n")
        
        response = await agent.ainvoke({"messages": conversation_history})
        conversation_history = response['messages']
        final_response = response['messages'][-1].content
        print(f"Agent: {final_response}\n")

if __name__ == "__main__":
    asyncio.run(main())
```

```typescript
import { Composio } from '@composio/core';
import { LangchainProvider } from '@composio/langchain';
import { MultiServerMCPClient } from "@langchain/mcp-adapters";  
import { createAgent } from "langchain";
import * as readline from 'readline';
import 'dotenv/config';

const composioApiKey = process.env.COMPOSIO_API_KEY;
const userId = process.env.COMPOSIO_USER_ID;

if (!composioApiKey) throw new Error('COMPOSIO_API_KEY is not set');
if (!userId) throw new Error('COMPOSIO_USER_ID is not set');

async function main() {
    const composio = new Composio({
        apiKey: composioApiKey as string,
        provider: new LangchainProvider()
    });

    const session = await composio.create(
        userId as string,
        {
            toolkits: ['cal']
        }
    );

    const url = session.mcp.url;
    
    const client = new MultiServerMCPClient({
        "cal-agent": {
            transport: "http",
            url: url,
            headers: {
                "x-api-key": process.env.COMPOSIO_API_KEY
            }
        }
    });
    
    const tools = await client.getTools();
  
    const agent = createAgent({ model: "gpt-5", tools });
    
    let conversationHistory: any[] = [];
    
    console.log("Chat started! Type 'exit' or 'quit' to end the conversation.\n");
    console.log("Ask any Cal related question or task to the agent.\n");
    
    const rl = readline.createInterface({
        input: process.stdin,
        output: process.stdout,
        prompt: 'You: '
    });

    rl.prompt();

    rl.on('line', async (userInput: string) => {
        const trimmedInput = userInput.trim();
        
        if (['exit', 'quit', 'bye'].includes(trimmedInput.toLowerCase())) {
            console.log("\nGoodbye!");
            rl.close();
            process.exit(0);
        }
        
        if (!trimmedInput) {
            rl.prompt();
            return;
        }
        
        conversationHistory.push({ role: "user", content: trimmedInput });
        console.log("\nAgent is thinking...\n");
        
        const response = await agent.invoke({ messages: conversationHistory });
        conversationHistory = response.messages;
        
        const finalResponse = response.messages[response.messages.length - 1]?.content;
        console.log(`Agent: ${finalResponse}\n`);
        
        rl.prompt();
    });

    rl.on('close', () => {
        console.log('\nSession ended.');
        process.exit(0);
    });
}

main().catch((err) => {
    console.error('Fatal error:', err);
    process.exit(1);
});
```

## Conclusion

You've successfully built a LangChain agent that can interact with Cal through Composio's Tool Router.
Key features of this implementation:
- Dynamic tool loading through Composio's Tool Router
- Conversation history maintenance for context-aware responses
- Async Python provides clean, efficient execution of agent workflows
You can extend this further by adding error handling, implementing specific business logic, or integrating additional Composio toolkits to create multi-app workflows.

## How to build Cal MCP Agent with another framework

- [OpenAI Agents SDK](https://composio.dev/toolkits/cal/framework/open-ai-agents-sdk)
- [Claude Agent SDK](https://composio.dev/toolkits/cal/framework/claude-agents-sdk)
- [Claude Code](https://composio.dev/toolkits/cal/framework/claude-code)
- [Claude Cowork](https://composio.dev/toolkits/cal/framework/claude-cowork)
- [Codex](https://composio.dev/toolkits/cal/framework/codex)
- [OpenClaw](https://composio.dev/toolkits/cal/framework/openclaw)
- [Hermes](https://composio.dev/toolkits/cal/framework/hermes-agent)
- [CLI](https://composio.dev/toolkits/cal/framework/cli)
- [Google ADK](https://composio.dev/toolkits/cal/framework/google-adk)
- [Vercel AI SDK](https://composio.dev/toolkits/cal/framework/ai-sdk)
- [Mastra AI](https://composio.dev/toolkits/cal/framework/mastra-ai)
- [LlamaIndex](https://composio.dev/toolkits/cal/framework/llama-index)
- [CrewAI](https://composio.dev/toolkits/cal/framework/crew-ai)

## Related Toolkits

- [Google Calendar](https://composio.dev/toolkits/googlecalendar) - Google Calendar is a time management service for scheduling meetings, events, and reminders. It streamlines personal and team organization with integrated notifications and sharing options.
- [Apaleo](https://composio.dev/toolkits/apaleo) - Apaleo is a cloud-based property management platform for hospitality businesses. It centralizes reservations, billing, and daily operations for smoother hotel management.
- [Appointo](https://composio.dev/toolkits/appointo) - Appointo is an appointment booking platform for Shopify stores. It lets businesses add online scheduling to their websites with zero coding.
- [Bart](https://composio.dev/toolkits/bart) - Bart is the Bay Area Rapid Transit system, providing fast public transportation across the San Francisco Bay Area. It helps commuters and travelers get real-time schedule info, plan routes, and stay updated on service changes.
- [Bookingmood](https://composio.dev/toolkits/bookingmood) - Bookingmood is commission-free booking software for rental businesses. It lets you manage reservations and sync bookings directly on your website.
- [Booqable](https://composio.dev/toolkits/booqable) - Booqable is a rental software platform for managing inventory, bookings, and reservations. It helps businesses streamline rentals and keep track of every item with ease.
- [Calendarhero](https://composio.dev/toolkits/calendarhero) - Calendarhero is a powerful scheduling platform that streamlines your calendar management across multiple services. It helps you efficiently schedule, reschedule, and organize meetings without the back-and-forth.
- [Calendly](https://composio.dev/toolkits/calendly) - Calendly is an appointment scheduling tool that automates meeting invitations, availability checks, and reminders. It helps individuals and teams avoid endless email back-and-forth when booking meetings.
- [Etermin](https://composio.dev/toolkits/etermin) - eTermin is an online appointment scheduling platform for businesses to manage bookings. It streamlines client appointments, saving time and reducing scheduling conflicts.
- [Evenium](https://composio.dev/toolkits/evenium) - Evenium is an all-in-one platform for managing professional events, from planning to analysis. It helps teams simplify event logistics, boost engagement, and track every detail in one place.
- [Eventee](https://composio.dev/toolkits/eventee) - Eventee is a user-friendly event management platform for mobile and web. It boosts attendee engagement for in-person, virtual, and hybrid events.
- [Eventzilla](https://composio.dev/toolkits/eventzilla) - Eventzilla is an event management platform for creating, promoting, and running events. It streamlines ticketing, registration, and attendee coordination for organizers.
- [Humanitix](https://composio.dev/toolkits/humanitix) - Humanitix is a not-for-profit ticketing platform that donates 100% of profits to charity. It empowers event organizers to make social impact with every ticket sold.
- [Lodgify](https://composio.dev/toolkits/lodgify) - Lodgify is an all-in-one vacation rental software for property managers and owners. It centralizes bookings, guest messaging, and channel synchronization in one dashboard.
- [Planyo Online Booking](https://composio.dev/toolkits/planyo_online_booking) - Planyo Online Booking is a flexible reservation system for managing bookings by day, hour, or event. It streamlines scheduling for any business needing reservations.
- [Scheduleonce](https://composio.dev/toolkits/scheduleonce) - Scheduleonce is a scheduling platform for capturing, qualifying, and engaging with inbound leads. It streamlines appointment booking and follow-ups for faster lead conversion.
- [Supersaas](https://composio.dev/toolkits/supersaas) - Supersaas is a flexible appointment scheduling platform for businesses and individuals. It streamlines bookings, reminders, and calendar management in one place.
- [Sympla](https://composio.dev/toolkits/sympla) - Sympla is a platform for managing in-person and online events, ticket sales, and registrations. It streamlines event setup, attendee tracking, and digital content delivery.
- [Gmail](https://composio.dev/toolkits/gmail) - Gmail is Google's email service with powerful spam protection, search, and G Suite integration. It keeps your inbox organized and makes communication fast and reliable.
- [Google Drive](https://composio.dev/toolkits/googledrive) - Google Drive is a cloud storage platform for uploading, sharing, and collaborating on files. It's perfect for keeping your documents accessible and organized across devices.

## Frequently Asked Questions

### What are the differences in Tool Router MCP and Cal MCP?

With a standalone Cal MCP server, the agents and LLMs can only access a fixed set of Cal tools tied to that server. However, with the Composio Tool Router, agents can dynamically load tools from Cal and many other apps based on the task at hand, all through a single MCP endpoint.

### Can I use Tool Router MCP with LangChain?

Yes, you can. LangChain fully supports MCP integration. You get structured tool calling, message history handling, and model orchestration while Tool Router takes care of discovering and serving the right Cal tools.

### Can I manage the permissions and scopes for Cal while using Tool Router?

Yes, absolutely. You can configure which Cal scopes and actions are allowed when connecting your account to Composio. You can also bring your own OAuth credentials or API configuration so you keep full control over what the agent can do.

### How safe is my data with Composio Tool Router?

All sensitive data such as tokens, keys, and configuration is fully encrypted at rest and in transit. Composio is SOC 2 Type 2 compliant and follows strict security practices so your Cal data and credentials are handled as safely as possible.

---
[See all toolkits](https://composio.dev/toolkits) · [Composio docs](https://docs.composio.dev/llms.txt)