MCP Overview

The Chronary API doubles as a Model Context Protocol (MCP) server. Any MCP-compatible AI client — Claude Desktop, Cursor, ChatGPT, or your own agent — can discover and call Chronary’s calendar tools without writing integration code.

What is MCP?

The Model Context Protocol is an open standard that lets AI models discover and invoke tools at runtime. Instead of hardcoding API calls, the AI client asks the server “what tools do you have?”, gets back structured schemas, and calls them directly.

Think of it as USB-C for AI tools — one protocol, universal compatibility.

Why MCP vs REST?

Both interfaces hit the same backend — same data, same quotas, same rate limits. Choose based on your use case:

Use MCP when...

Your AI agent runs inside an MCP client (Claude Desktop, Cursor, custom agent). The client discovers tools automatically — no API docs or SDK needed.

Use REST when...

You’re building traditional backend integrations, webhooks, cron jobs, or need fine-grained HTTP control (status codes, pagination headers, etc.).

	MCP	REST
Tool discovery	Automatic — client reads schemas at connect time	Manual — you read the docs and write calls
Schema validation	Built into the protocol	You validate inputs yourself
AI framework support	Native in Claude, Cursor, ChatGPT, LangChain, etc.	Requires custom function definitions
Granularity	9 high-level tools	Full endpoint surface with query parameters
Best for	AI agents and copilots	Backend services and scripts

Architecture

┌─────────────┐     ┌──────────────┐     ┌──────────────────────┐
│  Your Agent  │────▶│  MCP Client  │────▶│  Chronary MCP Server │
│  (LLM)      │◀────│  (SDK/App)   │◀────│  (Cloudflare Worker) │
└─────────────┘     └──────────────┘     └──────────┬───────────┘
                                                    │
                                          Same service layer
                                                    │
                                         ┌──────────▼───────────┐
                                         │   Chronary Backend   │
                                         │  (DB, Cache, Jobs)   │
                                         └──────────────────────┘

The MCP server runs inside the same Cloudflare Worker as the REST API. When an MCP client calls create_event, it executes the exact same service-layer code as POST /v1/calendars/:id/events. No separate deployment, no data sync — one backend, two interfaces.

Transport

Chronary uses Streamable HTTP transport — the web-standard MCP transport that works with Cloudflare Workers and any HTTP client.

Endpoint	Method	Purpose
`/mcp`	`POST`	Send MCP requests (tool calls, initialization)
`/mcp`	`GET`	Server-Sent Events stream (for streaming responses)

Authentication

MCP uses the same API key authentication as the REST API. Pass your key in the Authorization header:

Authorization: Bearer chr_sk_test_your_key_here

Test keys (chr_sk_test_) and live keys (chr_sk_live_) both work. Test mode data is isolated from live data.

Same data, same limits

There is no separate “MCP mode.” Everything is shared:

Data — agents, calendars, and events created via MCP are visible via REST (and vice versa)
Quotas — MCP tool calls count against your plan’s API call limit
Rate limits — same per-second and per-minute limits apply
API keys — same key works for both interfaces

Available tools

Chronary exposes 9 MCP tools covering agents, calendars, events, availability, and iCal subscriptions:

Agent management

create_agent and list_agents

Calendar operations

create_calendar

Event operations

create_event, list_events, and cancel_event

Availability

get_availability and find_meeting_time

iCal sync

subscribe_ical

Next steps

Setup Connect Chronary to Claude Desktop, Cursor, or your own agent

Tools Reference All 9 tools with parameters and examples

REST API Reference Full HTTP endpoint documentation