Overview

The Routine MCP (Model Context Protocol) Server lets developers expose your Routine calendars, tasks, and notes to any MCP-compatible client or assistant. It implements the MCP server side for Routine so assistants (for example, Claude Desktop or other MCP clients) can query, create, and update context items — enabling downstream models to read and act on your schedule and project data.

This server communicates over stdin/stdout and follows the MCP framing conventions so it can be launched directly (via npx or a Node executable) by an MCP client. Use it to keep model-driven assistants in sync with your Routine account, automate schedule changes, or provide contextual task and note access inside custom apps.

Features

Sync Routine calendars, events, tasks, and notes with MCP clients
Read and write operations for calendar events, tasks, and notes
Stream or subscribe to context updates (when supported by the client)
Works as a drop-in MCP server (launch via npx or direct node execution)
Designed for use with MCP-enabled assistants such as Claude Desktop
Lightweight: communicates over stdin/stdout using JSON messages

Installation / Configuration

Install and run the published server quickly with npx:

# Run the MCP server directly (production / simple usage)
npx routine-mcp-server

For development, clone the repo, install dependencies, and build:

# clone & install
git clone https://github.com/routineco/mcp-server.git
cd mcp-server
yarn

# build the project
yarn build

# run the built server locally
yarn start

Claude Desktop (or any MCP client that launches a local server) can be configured to start the server automatically. Example using npx:

{
  "mcpServers": {
    "routine": {
      "command": "npx",
      "args": ["routine-mcp-server"]
    }
  }
}

When running from a built copy of the repo, point to the node executable and the built entry:

{
  "mcpServers": {
    "routine": {
      "command": "/absolute/path/to/bin/node",
      "args": ["/absolute/path/to/mcp-server/dist/index.js"]
    }
  }
}

Available Resources

The server exposes Routine resources that MCP clients can use. Typical resource categories and example capabilities:

Resource	Example operations
Calendar	list calendars, list events, get event, create/update/delete event
Tasks	list tasks/projects, create/update/delete tasks, change task status
Notes	list notes, get note content, create/update/delete notes
Sync / Subscriptions	subscribe to changes, push updates to clients

Each resource is intended to be accessed through the MCP tool invocation mechanism. The exact method names and schemas follow the server’s MCP manifest; clients can discover capabilities at runtime.

Running & Interaction

Launch the server (npx or built binary).
The server reads and writes JSON framed messages on stdin/stdout according to MCP.
MCP clients will invoke tools/resources exposed by the server to fetch and modify Routine data.

A minimal conceptual example of an MCP-style request (actual field names may vary depending on client):

{
  "id": "req-1",
  "type": "request",
  "method": "invoke",
  "params": {
    "tool": "calendar.listEvents",
    "args": { "calendarId": "primary", "from": "2026-04-01", "to": "2026-04-30" }
  }
}

The server responds with a JSON result over stdout that contains the requested items or an error object.

Use Cases

Automating schedule edits: A virtual assistant can create or move events when you ask it to reschedule a meeting, and reflect those changes back into Routine.
Context-aware writing assistants: A model can access nearby notes and tasks to produce more informed summaries or project updates.
Cross-tool workflows: Sync tasks from Routine into another productivity workflow or trigger reminders based on task status changes via MCP-driven automations.
Embedded tooling: Integrate Routine data into a custom MCP-enabled interface (desktop assistant, CLI helper, or internal tooling) without managing OAuth or API calls directly in your assistant logic.

Concrete example:

You configure Claude Desktop to run the Routine MCP server. While drafting an email, you ask the assistant: “What does my afternoon look like?” The assistant invokes calendar.listEvents via MCP, receives events for the timeframe, and suggests free slots or creates a new event on your behalf when you confirm.

Development

Use yarn for dependency management and build steps (yarn, yarn build).
The development server logs and behavior can be inspected by running the built entry directly with node and watching stdout/stderr.
The server is designed to be embedded by MCP clients, so during development use absolute paths in client configs or use the npx shortcut for quick testing.

Resources

Repository: https://github.com/routineco/mcp-server
Model Context Protocol (MCP): https://modelcontextprotocol.io
Routine app: https://routine.co/download

If you’re integrating a new MCP client or building automations, consult the repository’s README and source for the exact tool manifest and message schemas to ensure proper invocation and typing.

Routine MCP Server: Calendars, Tasks, Notes