Skip to main content
Glama
kalendis-dev

Kalendis MCP

Official
by kalendis-dev
OverviewSchemaRelated ServersScoreDiscussions
TypeScript
Remote

Kalendis MCP Tool

npm version License: MIT

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/mcp

Quick 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 together

API 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.dev

  • production: 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 build

Contributing

Contributions are welcome! Please feel free to submit a Pull Request.

  1. Fork the repository

  2. Create your feature branch (git checkout -b feature/amazing-feature)

  3. Commit your changes (git commit -m 'Add some amazing feature')

  4. Push to the branch (git push origin feature/amazing-feature)

  5. Open a Pull Request

License

This project is licensed under the MIT License - see the LICENSE file for details.

Support

For issues or questions:

Available Tools

4 tools
generate-api-routesC

Generate API route handlers for Next.js or Express that use the Kalendis backend client

ParametersJSON Schema
NameRequiredDescriptionDefault
frameworkYesTarget framework
typesImportPathNoImport path for types file (optional, defaults to "@/lib/types" for Next.js)

TDQS

C2.9/5.0
Behavior2/5

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 what the tool does but lacks details on behavioral traits such as whether it modifies files, requires specific permissions, handles errors, or produces output format. For a generation tool with zero annotation coverage, this is a significant gap.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It is appropriately sized and front-loaded, making it easy to understand quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the complexity of generating API route handlers and the lack of annotations and output schema, the description is incomplete. It doesn't explain what the tool outputs (e.g., code files, configuration), how to handle the results, or any dependencies. For a tool with 2 parameters and no structured output information, more context is needed.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already documents both parameters ('framework' and 'typesImportPath') with descriptions and enums. The description adds no additional meaning beyond what the schema provides, such as explaining how the parameters affect the generation process. Baseline 3 is appropriate when the schema does the heavy lifting.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Generate API route handlers for Next.js or Express that use the Kalendis backend client.' It specifies the verb ('generate'), resource ('API route handlers'), and technology context. However, it doesn't explicitly differentiate from sibling tools like 'generate-backend-client' or 'generate-frontend-client' beyond mentioning the backend client usage.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 mentions using the Kalendis backend client, but doesn't explain when to choose this over sibling tools like 'generate-backend-client' or 'list-endpoints,' nor does it specify prerequisites or exclusions for usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

generate-backend-clientB

Generate a TypeScript client that calls Kalendis API directly with x-api-key authentication

ParametersJSON Schema
NameRequiredDescriptionDefault
environmentNoTarget environment (optional, defaults to production)
typesImportPathNoImport path for types file (optional, defaults to "../types")

TDQS

B3.4/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It mentions authentication but doesn't cover other important aspects like whether this is a read/write operation, what permissions are needed, what the output looks like (e.g., file generation), or any rate limits. The description is minimal and lacks behavioral context.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose without any unnecessary words. It's appropriately sized and front-loaded with the core functionality.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given no annotations and no output schema, the description is incomplete for a tool that generates code. It doesn't explain what the output is (e.g., a file, code snippet), how it's delivered, or any behavioral traits. The description alone is insufficient for understanding the tool's full behavior.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema already fully documents both parameters with descriptions and enum values. The description doesn't add any parameter-specific information beyond what's in the schema, meeting the baseline for high schema coverage.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose5/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the specific action ('Generate a TypeScript client'), the target ('Kalendis API'), and the authentication method ('x-api-key authentication'). It distinguishes from sibling tools like 'generate-api-routes' and 'generate-frontend-client' by specifying it's for backend/direct API calls.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines3/5

Does the description explain when to use this tool, when not to, or what alternatives exist?

The description implies usage for generating a TypeScript client with specific authentication, but doesn't explicitly state when to use this tool versus alternatives like 'generate-frontend-client' or 'generate-api-routes'. No explicit exclusions or prerequisites are mentioned.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

generate-frontend-clientC

Generate a TypeScript client for frontend apps that calls your backend API endpoints

ParametersJSON Schema
NameRequiredDescriptionDefault
typesImportPathNoImport path for types file (optional, defaults to "../types")

TDQS

C2.9/5.0
Behavior2/5

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. While it indicates this is a generation tool (implying a write operation), it lacks details on permissions needed, whether it overwrites existing files, what the output format is, or any rate limits. The description is minimal and doesn't provide sufficient behavioral context for safe use.

Agents need to know what a tool does to the world before calling it. Descriptions should go beyond structured annotations to explain consequences.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose without unnecessary words. It's appropriately sized and front-loaded, with every element contributing to understanding.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

For a generation tool with no annotations and no output schema, the description is incomplete. It doesn't explain what the generated client includes, how it's structured, where it's saved, or what happens if files already exist. Given the complexity implied by generating a TypeScript client, more context is needed for effective use.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters3/5

Does the description clarify parameter syntax, constraints, interactions, or defaults beyond what the schema provides?

Schema description coverage is 100%, so the schema fully documents the single optional parameter. The description doesn't add any parameter-specific information beyond what's in the schema, but with high coverage and only one parameter, the baseline score of 3 is appropriate.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the tool's purpose: 'Generate a TypeScript client for frontend apps that calls your backend API endpoints'. It specifies the verb ('Generate'), resource ('TypeScript client'), and target context ('frontend apps'), but doesn't explicitly differentiate from sibling tools like 'generate-backend-client' or 'generate-api-routes'.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 'generate-backend-client' or 'generate-api-routes', nor does it specify prerequisites, appropriate contexts, or exclusions for usage.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

list-endpointsB

List all available Kalendis API endpoints with descriptions

ParametersJSON Schema
NameRequiredDescriptionDefault

No parameters

TDQS

B3.1/5.0
Behavior2/5

Does the description disclose side effects, auth requirements, rate limits, or destructive behavior?

With no annotations provided, the description carries the full burden of behavioral disclosure. It states the tool lists endpoints but doesn't mention if it's read-only, safe, requires authentication, has rate limits, or what the output format looks like. This is a significant gap for a tool with zero 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.

Conciseness5/5

Is the description appropriately sized, front-loaded, and free of redundancy?

The description is a single, efficient sentence that directly states the tool's purpose without any wasted words. It is appropriately sized and front-loaded, making it easy for an agent to parse quickly.

Shorter descriptions cost fewer tokens and are easier for agents to parse. Every sentence should earn its place.

Completeness2/5

Given the tool's complexity, does the description cover enough for an agent to succeed on first attempt?

Given the tool's complexity is low (0 parameters), but with no annotations and no output schema, the description is incomplete. It doesn't explain what the return values look like (e.g., list format, endpoint details) or behavioral aspects, leaving gaps for the agent to infer.

Complex tools with many parameters or behaviors need more documentation. Simple tools need less. This dimension scales expectations accordingly.

Parameters4/5

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, and a baseline score of 4 is appropriate for this case as it avoids misleading or redundant information.

Input schemas describe structure but not intent. Descriptions should explain non-obvious parameter relationships and valid value ranges.

Purpose4/5

Does the description clearly state what the tool does and how it differs from similar tools?

The description clearly states the verb ('List') and resource ('all available Kalendis API endpoints with descriptions'), making the purpose specific and understandable. It doesn't explicitly differentiate from sibling tools like 'generate-api-routes', but the purpose is well-defined.

Agents choose between tools based on descriptions. A clear purpose with a specific verb and resource helps agents select the right tool.

Usage Guidelines2/5

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 like 'generate-api-routes' or other sibling tools. It lacks context about prerequisites, timing, or exclusions, leaving the agent without usage direction.

Agents often have multiple tools that could apply. Explicit usage guidance like "use X instead of Y when Z" prevents misuse.

Tool Schema Changelog

Recent tool additions, removals, and schema changes observed during successful MCP inspections. Dates show when Glama detected each change.

  1. 4 tool updates
    • First observedgenerate-api-routes
    • First observedgenerate-backend-client
    • First observedgenerate-frontend-client
    • First observedlist-endpoints
Install Server
RayrunBuild, deploy, and operate MCP servers without becoming an infrastructure team.ray.runAd

TDQS

B3.4/5.0
Disambiguation5/5

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.

Naming Consistency5/5

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.

Tool Count4/5

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.

Completeness4/5

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

ActivityInactive
ResponsivenessSyncing

Resources

Unclaimed servers have limited discoverability.

Looking for Admin?

If you are the server author, to access and configure the admin panel.

Related MCP Connectors

Related MCP Servers

Latest Blog Posts

MCP directory API

We provide all the information about MCP servers via our MCP API.

curl -X GET 'https://glama.ai/api/mcp/v1/servers/kalendis-dev/kalendis-mcp'

If you have feedback or need assistance with the MCP directory API, please join our Discord server