TwoMinuteTimeline
Slide Deck Quality Gantt Charts in 2 minutes or less

Hosted MCP server

Connect any MCP-aware AI assistant — Claude.ai, Claude Desktop, Cursor, and others — to get a create_timeline tool that renders Gantt charts inline. The server is hosted, public, and uses the standard Streamable HTTP transport. No install, no auth, no config beyond a single URL.

MCP /mcp
Fair use: The MCP endpoint shares the same rate limit as the HTTP API — 20 requests / minute per IP, 64KB body cap. No auth required.

What is MCP?

The Model Context Protocol is the standard AI assistants use to discover and call external tools. A remote MCP server is just an HTTPS endpoint that speaks JSON-RPC — point your client at it and the tool shows up in every chat.

This server exposes one tool, create_timeline, with the same JSON shape as the HTTP API. The agent calls it, the server renders a PNG, the chart appears inline.

Hosted vs. self-hosted

Hosted (this URL)Self-host (stdio)
SetupPaste URL, or 1 npx lineClone repo, npm install
AuthNoneNone
Rate limit20 req/min per IPNone locally
Network hopYesOptional
Best forMost usersAir-gapped / private

Option A — Claude.ai (web)

For Claude Pro / Team / Enterprise accounts that support custom connectors:

  1. Open Settings → Connectors (or the integrations menu in a chat).
  2. Click Add custom connector and paste the URL below.
  3. Save. The create_timeline tool is now available in every chat on that account.
https://www.twominutetimeline.com/mcp

Option B — Claude Desktop, Cursor, stdio clients

Use the mcp-remote bridge — a tiny shim that lets a stdio-based client talk to a remote HTTP server. Open the client's MCP config:

  • Claude Desktop, macOS: ~/Library/Application Support/Claude/claude_desktop_config.json
  • Claude Desktop, Windows: %APPDATA%\Claude\claude_desktop_config.json
  • Cursor: ~/.cursor/mcp.json

Add (or merge into) this entry, then restart the client:

{
  "mcpServers": {
    "two-minute-timeline": {
      "command": "npx",
      "args": ["-y", "mcp-remote", "https://www.twominutetimeline.com/mcp"]
    }
  }
}

Once it's loaded, ask "Make a Gantt chart for a 6-week launch with discovery, design, dev, QA, and launch phases" and the assistant will call the tool and embed the chart inline.

Option C — self-host (stdio)

Run a local stdio MCP server that calls the same upstream API. Useful if you want everything local, want to point at a private timeline API, or are inside an air-gapped network.

git clone <repo-url>
cd two-minute-timeline/mcp-server
npm install

Then register it with your client (example for Claude Desktop):

{
  "mcpServers": {
    "two-minute-timeline": {
      "command": "node",
      "args": ["/absolute/path/to/mcp-server/index.js"]
    }
  }
}

To point at a different upstream API, set TIMELINE_API_URL in the server's env block.

Smoke test from a terminal

Verify the endpoint is reachable and discover its tools without any client at all:

curl -X POST 'https://www.twominutetimeline.com/mcp' \
  -H 'Content-Type: application/json' \
  -H 'Accept: application/json, text/event-stream' \
  -d '{"jsonrpc":"2.0","id":1,"method":"tools/list"}'

Returns a JSON envelope describing the create_timeline tool and its input schema.

Wire format

The endpoint speaks the MCP Streamable HTTP transport (stateless). Every interaction is a JSON-RPC POST. The full handshake is:

  1. initialize — negotiate protocol version and capabilities.
  2. notifications/initialized — client signals ready.
  3. tools/list — discover the create_timeline tool.
  4. tools/call — invoke it with a JSON payload; receive PNG image content back.

Most clients handle this for you. Tool input is identical to the HTTP API request body — title, columns, unit, tasks, etc.