Kalendis MCP
OfficialGenerates API route handlers for Express applications that integrate with the Kalendis scheduling API
Generates Fastify plugin with route handlers for integrating Kalendis scheduling functionality into Fastify applications
Generates complete NestJS modules including controllers, services, and modules for Kalendis scheduling API integration
Generates App Router API routes for Next.js applications to integrate with Kalendis scheduling services
Generates type-safe TypeScript clients for both backend and frontend applications to interact with the Kalendis scheduling API
Click on "Deploy Server".
Wait a few minutes for the server to deploy. Once ready, it will show a "Started" state.
In the chat, type
@followed by the MCP server name and your instructions, e.g., "@Kalendis MCP generate a TypeScript client for my Next.js app to manage user bookings"
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.
Kalendis MCP Tool
MCP (Model Context Protocol) server and client generator for Kalendis scheduling API integration.
Features
🔧 MCP Server: Exposes Kalendis API tools for use with Claude, Cursor, etc
🚀 Client Generator: Generates TypeScript clients for backend and frontend applications
🛣️ Route Generator: Creates API route handlers for Next.js, Fastify, NestJS and Express
🔐 Secure: Uses environment variables for API key management
📝 Type-safe: Full TypeScript support with generated types
Related MCP server: @aiwerk/mcp-server-cal
Installation
npm install @kalendis/mcpQuick Start
1. Get Your API Key
Before using the Kalendis MCP tool, you'll need an API key. Create a free account at kalendis.dev to get started. Your API key will be available in your account dashboard and is required for authenticating requests to the Kalendis scheduling API.
2. Configure MCP Server
Quick Install (Cursor IDE)
Click the button below to automatically add Kalendis to your Cursor IDE:
Manual Configuration
Alternatively, add this to your MCP settings:
{
"mcpServers": {
"kalendis": {
"command": "npx",
"args": ["-y", "@kalendis/mcp"]
}
}
}3. Available MCP Tools
Once configured, the AI agent can use these tools:
generate-backend-client: Generate a TypeScript client for direct API calls
generate-frontend-client: Generate a TypeScript client for frontend applications
generate-api-routes: Generate API route handlers for Next.js, Express, Fastify, or NestJS
list-endpoints: List all available Kalendis API endpoints
Client Generation
Backend Client
Generate a client that calls the Kalendis API directly:
// Generated client usage
import KalendisClient from './generated/kalendis-client';
// Initialize with your API key (from environment variable, config, etc.)
const client = new KalendisClient({
apiKey: process.env.MY_API_KEY, // You choose the env var name
});
const users = await client.getUsers();
const user = await client.createUser({ name: 'John Doe', email: 'john@example.com' });Frontend Client
Generate a client that calls your backend API endpoints:
// Generated frontend client usage
import api from './generated/frontend-client';
// Calls your backend endpoints (e.g., /api/users)
const users = await api.getUsers();API Routes
Next.js Routes
Generates App Router API routes:
// app/api/users/route.ts
export async function GET(request: Request) {
// Implementation using backend client
}Express Routes
Generates Express router handlers:
// routes/api.ts
router.get('/users', async (req, res) => {
// Implementation using backend client
});Fastify Routes
Generates Fastify plugin with route handlers:
// routes/kalendis.ts
export default async function routes(fastify: FastifyInstance) {
fastify.get('/api/users', async (request, reply) => {
// Implementation using backend client
return users;
});
}NestJS Module
Generates complete NestJS module with controller, service, and module files:
// kalendis.controller.ts
@Controller('api')
export class KalendisController {
@Get('users')
async getUsers() {
return this.kalendisService.getUsersByAccountId();
}
}
// kalendis.service.ts - Wraps the backend client
// kalendis.module.ts - Wire everything togetherAPI Endpoints Coverage
The tool supports all 28 Kalendis API endpoints:
Users
GET /v1/users - Fetch all users
POST /v1/users - Create user
PUT /v1/users/:id - Update user
DELETE /v1/users/:id - Delete user
Availability
GET /v1/availability - Get availability with filters
GET /v1/availability/all - Get all availability
GET /v1/availability/calculated - Get calculated availability
GET /v1/availability/recurring - Get recurring availability
GET /v1/availability/matching - Get matching availability
POST /v1/availability - Add availability
PUT /v1/availability/:id - Update availability
DELETE /v1/availability/:id - Delete availability
Recurring Availability
GET /v1/recurring-availability - Get recurring availability
POST /v1/recurring-availability - Add recurring availability
PUT /v1/recurring-availability/:id - Update recurring availability
DELETE /v1/recurring-availability/:id - Delete recurring availability
Availability Exceptions
GET /v1/availability-exceptions - Get exceptions
POST /v1/availability-exceptions - Add exception
POST /v1/availability-exceptions/recurring - Add recurring exception
PUT /v1/availability-exceptions/:id - Update exception
DELETE /v1/availability-exceptions/:id - Delete exception
Bookings
GET /v1/bookings - Get bookings
GET /v1/bookings/:userId - Get user bookings
POST /v1/bookings - Create booking
PUT /v1/bookings/:id - Update booking
DELETE /v1/bookings/:id - Delete booking
Account
GET /v1/account - Get account info
PUT /v1/account - Update account
Environment Configuration
The tool supports three environments:
development:
https://sandbox.api.kalendis.devproduction:
https://api.kalendis.dev
Authentication
All API calls to the Kalendis scheduling service require authentication via the x-api-key header.
The generated clients require you to provide an API key when instantiating:
// You control how to manage your API key
const client = new KalendisClient({
apiKey: process.env.KALENDIS_API_KEY, // or from config, secrets manager, etc.
});The generated API route handlers use environment variables by default, but you can customize this:
# Example: Set in your application's environment
export KALENDIS_API_KEY="your-api-key-here"Note: The MCP tool itself doesn't need or use the API key - it only generates code. The API key is used by the generated clients in your application.
Error Handling
The generated clients provide clear error messages:
401: Authentication failed - Invalid or missing API key
403: Permission denied - API key lacks required permissions
Network errors: Clear connection failure messages
API errors: Detailed error messages from the API
Development
To build the MCP tool locally:
git clone https://github.com/kalendis-dev/kalendis-mcp.git
cd kalendis-mcp
npm install
npm run buildContributing
Contributions are welcome! Please feel free to submit a Pull Request.
Fork the repository
Create your feature branch (
git checkout -b feature/amazing-feature)Commit your changes (
git commit -m 'Add some amazing feature')Push to the branch (
git push origin feature/amazing-feature)Open a Pull Request
License
This project is licensed under the MIT License - see the LICENSE file for details.
Support
For issues or questions:
Open an issue on GitHub
Email: support@kalendis.dev
Available Tools
4 toolsgenerate-api-routesC
Generate API route handlers for Next.js or Express that use the Kalendis backend client
Inputs: framework (required), typesImportPath.
generate-backend-clientB
Generate a TypeScript client that calls Kalendis API directly with x-api-key authentication
Inputs: environment, typesImportPath.
generate-frontend-clientC
Generate a TypeScript client for frontend apps that calls your backend API endpoints
Inputs: typesImportPath.
list-endpointsB
List all available Kalendis API endpoints with descriptions
Inputs: no named parameters.
Tool Schema Changelog
Recent tool additions, removals, and schema changes observed during successful MCP inspections.
Loading tool schema changelog…
TDQS
Scored across 4 tools
Each tool has a clearly distinct purpose: generate-api-routes creates backend route handlers, generate-backend-client builds a direct API client, generate-frontend-client creates a client for frontend apps, and list-endpoints provides API documentation. There is no overlap in functionality, making tool selection straightforward for an agent.
All tool names follow a consistent verb_noun pattern with 'generate-' or 'list-' prefixes, using kebab-case throughout. This predictability enhances readability and reduces cognitive load for agents when scanning the toolset.
Four tools is reasonable for a code generation and API documentation server, though it feels slightly minimal. The tools cover key workflows (client generation, route handling, endpoint listing), but additional utilities like validation or testing helpers could enhance completeness without overloading the set.
The toolset covers core aspects of integrating with the Kalendis API: generating clients for both backend and frontend, creating API routes, and listing endpoints. A minor gap exists in tools for managing API keys or handling errors, but agents can work around this with the provided tools for most common tasks.
Maintenance
Related MCP Connectors
Calendar API for AI agents: events, availability, Google/Microsoft setup, scheduling, and iCal.
Scheduling: event types, open slots, and booking, rescheduling or cancelling meetings in Caly.
Schedule, members, and bookings in your AI tools
AI-native scheduling and booking: check availability, book meetings, share links.
Related MCP Servers
- AlicenseAqualityDmaintenanceEnables interaction with Calendly to manage event types, scheduled events, and invitees. It provides tools for checking user availability and canceling appointments directly through the Calendly API.7MIT

@aiwerk/mcp-server-calofficial
AlicenseAqualityCmaintenanceConnects AI assistants to Cal.com for managing bookings, event types, and availability through natural language.1250 npmMIT- AlicenseNot gradedqualityDmaintenanceEnables scheduling and calendar management through Google Calendar and Cal.com, with support for reminders, notes, and email notifications.MIT
- AlicenseNot gradedqualityDmaintenanceExposes Cal.com scheduling tools to AI agents via MCP, enabling listing event types, checking availability, and managing bookings (create, cancel, reschedule).67 npmMIT