Pulumi Events MCP

MCP server for managing events on Meetup.com and Luma via AI assistants like Claude.

Built with FastMCP 3.x, it exposes Meetup's GraphQL API and Luma's REST API as MCP tools and resources so LLMs can search events, manage groups, create and publish events, and more.

Features

• 27 tools across two platforms (Meetup + Luma), tagged by platform and domain

• Invite-only Luma events end-to-end — require-approval, capacity + waitlist, registration questions, host management, and members-only visibility, all without touching the Luma UI

• 6 resources for read-only lookups (user profiles, group/event/network details)

• Cover image upload — pass a local file path when creating/updating events; the server handles CDN upload automatically (Luma presigned URL, Meetup two-step photo upload)

• Auto-pagination on all list tools — single tool call returns all results

• Meetup: JWT authentication for headless server-to-server access (no browser needed), with OAuth2 fallback

• Meetup Pro network search with member metadata (roles, events attended, group counts)

• Luma: API key authentication

• Stateless HTTP transport — no stale session issues on server restarts

• Provider architecture for easy addition of new platforms

Middleware

The server uses FastMCP's middleware stack for reliability and observability:

Tool Metadata

All tools include FastMCP metadata for better LLM integration:

• Tags — every tool is tagged by platform (meetup, luma) and domain (events, groups, members, etc.) for discovery and filtering

• Timeouts — 120-second timeout on upload-capable tools and all auto-paginating list tools to prevent hangs on slow networks

• Output schemas — key tools declare their response structure so LLM clients know what fields to expect

• Annotations — read-only tools are marked with readOnlyHint, idempotent tools with idempotentHint

Related MCP server: claude-sessions-mcp

Quick start

See the Getting Started guide for full setup instructions.

Cloud (deployed)

The server runs on AWS ECS Fargate behind CloudFront. Claude Code and Claude Desktop speak remote HTTP MCP natively — no proxy process needed:

claude mcp add --transport http pulumi-events https://<your-cloudfront-domain>/mcp

Claude handles the Google OAuth flow itself (/mcp → authenticate) and manages token refresh. For clients that only support stdio servers, fall back to mcp-remote:

{
  "mcpServers": {
    "pulumi-events": {
      "command": "npx",
      "args": ["mcp-remote", "https://<your-cloudfront-domain>/mcp"]
    }
  }
}

Headless environments (CI, sandboxes, scheduled agents) can't complete a browser OAuth flow. Set PULUMI_EVENTS_AUTH_TOKEN on the server and connect with the pre-shared token instead — it works alongside Google OAuth, not instead of it:

claude mcp add --transport http pulumi-events https://<your-cloudfront-domain>/mcp \
  --header "Authorization: Bearer <token>"

Google OAuth handles interactive MCP auth. Meetup authenticates automatically via JWT on server startup. The CloudFront domain is output by pulumi stack output cloudfront_url after deployment.

Local development

# Prerequisites: Python 3.12+, uv, Pulumi CLI (logged in)
git clone https://github.com/dirien/pulumi-events.git
cd pulumi-events
uv sync

# Start the server (credentials injected via Pulumi ESC)
pulumi env run ediri/pulumi-idp/auth -- uv run pulumi-events

Then point Claude Code at http://127.0.0.1:8080/mcp.

Tools

Meetup

Luma

Image Upload

Both platforms support event cover images through their create/update tools:

• Luma: Pass cover_image_path (local file path) to luma_create_event or luma_update_event. The server uploads to Luma's CDN via a presigned URL and sets the cover_url automatically.

• Meetup: Pass featured_image_path (local file path) to meetup_create_event or meetup_edit_event. The server uploads via Meetup's createGroupEventPhoto mutation and sets the featuredPhotoId. For create, the event is created first, then the photo is uploaded and attached via an edit (since Meetup's CreateEventInput doesn't support featuredPhotoId).

Supported image formats: JPEG, PNG, GIF, WebP, SVG, AVIF.

Sending Invites (Luma)

luma_send_invites takes an array of guests, each with a required email and an optional name:

{
  "event_id": "evt-abc123",
  "guests": [
    { "email": "ada@example.com", "name": "Ada Lovelace" },
    { "email": "alan@example.com" }
  ],
  "message": "Hope to see you there!"
}

name is ignored for people who already have a name on their Luma account. message is a single note applied to the whole batch (max 200 characters), not a per-guest field. People who are not yet on the guest list are added and invited.

Event Theming (Luma)

Pass tint_color (a hex string, e.g. "#bb2dc7") to luma_create_event or luma_update_event to set the event page theme color. Luma derives contrast-adjusted shades from it; alpha channels are stripped automatically. There is no API field for custom background images — only cover_url and tint_color.

New events default to #2f2356 when tint_color is omitted. Configure via PULUMI_EVENTS_LUMA_DEFAULT_TINT_COLOR (empty string disables the default); the cloud deployment reads it from the marketing/pulumi-events ESC environment (pulumi-events-infra:lumaDefaultTintColor). Updates never apply the default — an existing color is only changed when tint_color is passed explicitly.

Invite-Only Events (Luma)

A single luma_create_event call (plus luma_add_host per co-host) produces a fully configured invite-only event — private visibility, request-to-join approval, capacity with waitlist, and a custom registration form — with no Luma UI steps:

{
  "name": "Engineering Leadership Dinner",
  "start_at": "2026-09-10T17:00:00Z",
  "end_at": "2026-09-10T20:00:00Z",
  "timezone": "Europe/Berlin",
  "visibility": "private",
  "require_approval": true,
  "max_capacity": 12,
  "waitlist_status": "enabled",
  "registration_questions": [
    { "label": "Tell us more about you.", "required": true, "question_type": "text" }
  ],
  "cover_image_url": "https://example.com/cover.png"
}

The tool response is the event fetched back from the API, so most settings are verifiable in one round trip. Field-level behavior of Luma's public API (verified empirically):

Cross-Platform: Meetup to Luma

When copying an event from Meetup to Luma, the LLM should look up the venue's Google Maps place ID and pass it as geo_address_json:

// Recommended — Google Maps place ID (most reliable)
{"type": "google", "place_id": "ChIJJzpTdyB0nkcRblzKCp3kxeQ"}

Luma resolves the full address, coordinates, and map pin from the place ID automatically. Do NOT pass raw Meetup venue objects — they use an incompatible format. The server also strips invalid type fields server-side as a safety net.

Resources

Configuration

All settings are loaded from environment variables with the PULUMI_EVENTS_ prefix:

Authentication

The MCP endpoint supports two auth modes that compose:

• Google OAuth (when PULUMI_EVENTS_GOOGLE_CLIENT_ID/_SECRET are set) — the interactive flow for browser-capable clients.

• Pre-shared bearer token (when PULUMI_EVENTS_AUTH_TOKEN is set) — for headless clients. If Google credentials are also configured, the token is accepted in addition to Google-issued tokens; requests bearing neither are rejected. With only the token set, all MCP requests must include the Authorization: Bearer <token> header.

When neither is set, the server runs without auth (the default for local development).

To enable:

export PULUMI_EVENTS_AUTH_TOKEN="your-secret-token"

MCP clients must then send the token in the Authorization header. Example Claude Code config:

{
  "mcpServers": {
    "pulumi-events": {
      "type": "streamable-http",
      "url": "http://127.0.0.1:8080/mcp",
      "headers": {
        "Authorization": "Bearer your-secret-token"
      }
    }
  }
}

Health (/health) and OAuth callback (/auth/meetup/callback) routes are not affected by MCP auth.

Project Structure

src/pulumi_events/
├── server.py              # FastMCP instance, lifespan, middleware, custom routes
├── settings.py            # Pydantic Settings configuration
├── exceptions.py          # Exception hierarchy
├── utils.py               # Shared utilities (image MIME type detection)
├── auth/
│   ├── backends.py        # Pluggable token backends (File, Env)
│   ├── jwt_auth.py        # Meetup JWT auth (headless, server-to-server)
│   ├── oauth.py           # OAuth2 flow helpers (Meetup)
│   └── token_store.py     # Token persistence + auto-refresh
├── providers/
│   ├── base.py            # EventProvider protocol + capabilities
│   ├── registry.py        # Provider registry
│   ├── meetup/
│   │   ├── client.py      # GraphQL client with auto token refresh + binary upload
│   │   ├── provider.py    # MeetupProvider implementation + photo upload
│   │   ├── queries.py     # GraphQL query/mutation strings
│   │   └── models.py      # Pydantic response models
│   └── luma/
│       ├── client.py      # REST client for Luma public API + image upload
│       └── provider.py    # LumaProvider implementation
├── tools/
│   ├── _deps.py           # Shared dependency factories
│   ├── platform_tools.py  # list_platforms, meetup_login
│   ├── event_tools.py     # Meetup event mutations (with image upload)
│   ├── group_tools.py     # Meetup group tools
│   ├── member_tools.py    # Meetup member tools
│   ├── search_tools.py    # Meetup search tools
│   ├── venue_tools.py     # Meetup venue tools
│   └── luma_tools.py      # Luma event + guest tools (with image upload)
└── resources/
    ├── meetup_resources.py
    └── luma_resources.py

Deployment

The server is deployed to AWS ECS Fargate via Pulumi. Infrastructure code lives in deploy/.

deploy/
├── __main__.py       # Pulumi program (VPC, ECR, ECS, ALB, CloudFront, Secrets Manager)
├── Pulumi.yaml       # Project config (org: pulumi, toolchain: uv)
├── Pulumi.dev.yaml   # Stack config (ESC environments: marketing/aws-auth, marketing/pulumi-events)
├── pyproject.toml    # Pulumi SDK dependencies
└── uv.lock

Architecture: CloudFront (HTTPS) → ALB (HTTP) → ECS Fargate (port 8080)

Meetup authenticates headlessly via JWT on every container startup. Secrets are stored in AWS Secrets Manager and injected via ECS task definition. All config comes from Pulumi ESC.

cd deploy
pulumi up    # deploy or update
pulumi logs  # tail container logs

Development

make help       # Show all targets
make check      # Lint + format check
make format     # Auto-format
make test       # Run tests
make run        # Start the server

License

MIT